public static CmsSignedData Generate(IX509Store certificateStore, SignerInfo signerInfo, CmsProcessable content) { Asn1EncodableVector digestAlgs = new Asn1EncodableVector(); digestAlgs.Add(signerInfo.DigestAlgorithm); DerObjectIdentifier contentTypeOid = new DerObjectIdentifier(CmsObjectIdentifiers.Data.Id); Asn1EncodableVector signerInfos = new Asn1EncodableVector(); signerInfos.Add(signerInfo); Asn1Set certificates = CreateDerSetFromList(GetCertificatesFromStore(certificateStore)); Asn1Set certrevlist = null; ContentInfo encInfo = new ContentInfo(contentTypeOid, null); SignedData sd = new SignedData( new DerSet(digestAlgs), encInfo, certificates, certrevlist, new DerSet(signerInfos)); ContentInfo contentInfo = new ContentInfo(CmsObjectIdentifiers.SignedData, sd); return(new CmsSignedData(content, contentInfo)); }
public void Store_Local(DataReq store) { // getting published to - search results - patch SignedData signed = SignedData.Decode(store.Data); if (signed == null) { return; } G2Header embedded = new G2Header(signed.Data); // figure out data contained if (G2Protocol.ReadPacket(embedded)) { if (embedded.Name == LocationPacket.Data) { LocationData location = LocationData.Decode(signed.Data); if (Utilities.CheckSignedData(location.Key, signed.Data, signed.Signature)) { Process_LocationData(store, signed, location); } else { Debug.Assert(false); } } } }
private async Task <object> DoInvokeImpl(InvocationInfo info) { using (_stateHelper.GetFuncWrapper()) { var jsonRequest = JsonRpcClientProcessor.GetJsonRpcRequest(info); var requestPacket = new OneSideSignedRequestPacket() { JsonRpcRequest = Encoding.UTF8.GetBytes(jsonRequest.ToString()), SentTime = await _transport.GetNowTimeFunc().ConfigureAwait(false) }; SignedData <OneSideSignedRequestPacket> signedRequestPacket; using (var tempPass = _clientCertPass.TempData) { signedRequestPacket = new SignedData <OneSideSignedRequestPacket>( requestPacket, _clientCert, tempPass.Data ); } var serverAnswerData = await _transport.ProcessSignedRequestPacket( signedRequestPacket ).ThrowIfCancelled(_cts.Token).ConfigureAwait(false); return(await JsonRpcClientProcessor.GetJsonRpcResult( JObject.Parse( Encoding.UTF8.GetString( serverAnswerData ) ), info ).ConfigureAwait(false)); } }
public AnyCredential(ServiceContext serviceContext, bool legacyContext) { if (legacyContext) { core.v2_0.credential.CredentialData credential = UnmarshalLegacyCredential(serviceContext); Legacy = true; Bus = credential.bus; Login = credential.login; Session = credential.session; Ticket = credential.ticket; Hash = credential.hash; LegacyChain = credential.chain; } else { CredentialData credential = UnmarshalCredential(serviceContext); Legacy = false; Bus = credential.bus; Login = credential.login; Session = credential.session; Ticket = credential.ticket; Hash = credential.hash; Chain = credential.chain; } }
private CmsSignedData(CmsSignedData c) { signedData = c.signedData; contentInfo = c.contentInfo; signedContent = c.signedContent; signerInfoStore = c.signerInfoStore; }
public void TestCovariantSignedData() { var passBytes = Encoding.UTF8.GetBytes("TestPassword"); var testCertificate = LightCertificatesHelper.GenerateSelfSignedCertificate( ELightCertificateSignType.Rsa, 2048, ELightCertificateEncryptType.Rsa, 2048, EPrivateKeysKeyDerivationFunction.ScryptDefault, Guid.NewGuid(), "TestCertificate", passBytes ); var testB = new B() { Field1 = 1, Field2 = "sdasda", Field3 = Guid.NewGuid() }; _output.WriteLine(testB.WriteObjectToJson()); var testSignedData = new SignedData<B>( testB, testCertificate, passBytes ); var signedData2 = testSignedData.To<A>(); var testA = signedData2.GetValue(); _output.WriteLine(testA.WriteObjectToJson()); }
/// <summary> /// ContentInfo constructor - with encapsulated content /// </summary> /// <param name="sigData">A ContentInfo containing a signedData object.</param> public CmsSignedData( ContentInfo sigData) { this.contentInfo = sigData; this.signedData = SignedData.GetInstance(contentInfo.Content); // // this can happen if the signed message is sent simply to send a // certificate chain. // Asn1Encodable content = signedData.EncapContentInfo.Content; if (content != null) { if (content is Asn1OctetString) { this.signedContent = new CmsProcessableByteArray(signedData.EncapContentInfo.ContentType, ((Asn1OctetString)content).GetOctets()); } else { this.signedContent = new Pkcs7ProcessableObject(signedData.EncapContentInfo.ContentType, content); } } else { this.signedContent = null; } }
internal static CallChain UnmarshalCallChain(SignedData signed) { TypeCode chainTypeCode = OrbServices.GetSingleton().create_tc_for_type(typeof(CallChain)); return((CallChain)InterceptorsInitializer.Codec.decode_value(signed.encoded, chainTypeCode)); }
public CallerChain MakeChainFor(string entity) { ConnectionImpl conn = (ConnectionImpl)GetCurrentConnection(); if (conn == null) { Logger.Error("Não há conexão para executar a chamada MakeChainFor."); throw new NO_PERMISSION(NoLoginCode.ConstVal, CompletionStatus.Completed_No); } LoginInfo?myLogin = conn.Login; if (!myLogin.HasValue) { Logger.Error("Não há login para executar a chamada MakeChainFor."); throw new NO_PERMISSION(NoLoginCode.ConstVal, CompletionStatus.Completed_No); } try { AccessControl acs = conn.Acs; SignedData signedChain = acs.signChainFor(entity); CallChain callChain = CallerChainImpl.UnmarshalCallChain(signedChain); if (conn.Legacy) { SignedCallChain legacySigned = conn.LegacyConverter.signChainFor(entity); return(new CallerChainImpl(callChain.bus, callChain.caller, callChain.target, callChain.originators, signedChain, legacySigned)); } return(new CallerChainImpl(callChain.bus, callChain.caller, callChain.target, callChain.originators, signedChain)); } catch (GenericUserException e) { Logger.Error("Falha inesperada ao criar uma nova cadeia.", e); throw; } }
public void TestCovariantSignedData() { var passBytes = Encoding.UTF8.GetBytes("TestPassword"); var testCertificate = LightCertificatesHelper.GenerateSelfSignedCertificate( ELightCertificateSignType.Rsa, 2048, ELightCertificateEncryptType.Rsa, 2048, EPrivateKeysKeyDerivationFunction.ScryptDefault, Guid.NewGuid(), "TestCertificate", passBytes ); var testB = new B() { Field1 = 1, Field2 = "sdasda", Field3 = Guid.NewGuid() }; _output.WriteLine(testB.WriteObjectToJson()); var testSignedData = new SignedData <B>( testB, testCertificate, passBytes ); var signedData2 = testSignedData.To <A>(); var testA = signedData2.GetValue(); _output.WriteLine(testA.WriteObjectToJson()); }
private void Process_VersionedFile(DataReq data, SignedData signed, VersionedFileHeader header) { Core.IndexKey(header.KeyID, ref header.Key); OpVersionedFile current = GetFile(header.KeyID); // if link loaded if (current != null) { // lower version if (header.Version < current.Header.Version) { if (data != null && data.Source != null) { Store.Send_StoreReq(data.Source, data.LocalProxy, new DataReq(null, current.UserID, Service, DataType, current.SignedHeader)); } return; } // higher version else if (header.Version > current.Header.Version) { CacheFile(signed, header); } } // else load file, set new header after file loaded else { CacheFile(signed, header); } }
public CallerChain ImportChain(byte[] token, string domain) { ConnectionImpl conn = (ConnectionImpl)GetCurrentConnection(); if (conn == null) { throw new NO_PERMISSION(NoLoginCode.ConstVal, CompletionStatus.Completed_No); } AccessControl acs = conn.Acs; AsymmetricKeyParameter busKey = conn.BusKey; if (busKey == null) { throw new NO_PERMISSION(NoLoginCode.ConstVal, CompletionStatus.Completed_No); } byte[] encryptedToken = Crypto.Encrypt(busKey, token); SignedData signedChain = acs.signChainByToken(encryptedToken, domain); try { CallChain callChain = CallerChainImpl.UnmarshalCallChain(signedChain); return(new CallerChainImpl(callChain.bus, callChain.caller, callChain.target, callChain.originators, signedChain)); } catch (GenericUserException e) { const string message = "Falha inesperada ao importar uma nova cadeia."; Logger.Error(message, e); throw new OpenBusInternalException(message, e); } }
private void EndDownload(object[] args) { SignedData signedHeader = args[0] as SignedData; VersionedFileHeader header = args[1] as VersionedFileHeader; CacheFile(signedHeader, header); }
public CallerChain DecodeChain(byte[] encoded) { try { VersionedData[] versions = DecodeExportedVersions(encoded, _magicTagCallChain); CallerChainImpl decodedChain = null; for (int i = 0; i < versions.Length; i++) { // Se houver duas versões, a versão atual virá antes da versão legacy. if (versions[i].version == ExportVersion.ConstVal) { TypeCode signedDataTypeCode = ORB.create_tc_for_type(typeof(SignedData)); SignedData exportedChain = (SignedData) _codec.decode_value(versions[i].encoded, signedDataTypeCode); CallChain chain = CallerChainImpl.UnmarshalCallChain(exportedChain); if (decodedChain == null) { decodedChain = new CallerChainImpl(chain.bus, chain.caller, chain.target, chain.originators, exportedChain); } else { decodedChain.Signed.Chain = exportedChain; } } if (versions[i].version == CurrentVersion.ConstVal) { TypeCode exportedChainTypeCode = ORB.create_tc_for_type(typeof(ExportedCallChain)); ExportedCallChain exportedChain = (ExportedCallChain) _codec.decode_value(versions[i].encoded, exportedChainTypeCode); core.v2_0.services.access_control.CallChain chain = CallerChainImpl.UnmarshalLegacyCallChain(exportedChain.signedChain); if (decodedChain == null) { decodedChain = new CallerChainImpl(exportedChain.bus, chain.caller, chain.target, chain.originators, exportedChain.signedChain); } else { decodedChain.Signed.LegacyChain = exportedChain.signedChain; } } } if (decodedChain != null) { return(decodedChain); } } catch (GenericUserException e) { const string message = "Falha inesperada ao decodificar uma cadeia exportada."; Logger.Error(message, e); throw new InvalidEncodedStreamException(message, e); } throw new InvalidEncodedStreamException("Versão de cadeia incompatível."); }
private CmsSignedData(CmsSignedData c) { this.signedData = c.signedData; this.contentInfo = c.contentInfo; this.signedContent = c.signedContent; this.signerInfoStore = c.signerInfoStore; }
public static bool Validate(SignedData signedData) { //todo: Signature will be validated using parameter fields //now always return signature is valid //todo: add real implementation code return(true); }
public static CmsSignedData ReplaceSigners(CmsSignedData signedData, SignerInformationStore signerInformationStore) { CmsSignedData cmsSignedData = new CmsSignedData(signedData); cmsSignedData.signerInfoStore = signerInformationStore; Asn1EncodableVector asn1EncodableVector = new Asn1EncodableVector(); Asn1EncodableVector asn1EncodableVector2 = new Asn1EncodableVector(); foreach (SignerInformation signer in signerInformationStore.GetSigners()) { asn1EncodableVector.Add(Helper.FixAlgID(signer.DigestAlgorithmID)); asn1EncodableVector2.Add(signer.ToSignerInfo()); } Asn1Set asn1Set = new DerSet(asn1EncodableVector); Asn1Set asn1Set2 = new DerSet(asn1EncodableVector2); Asn1Sequence asn1Sequence = (Asn1Sequence)signedData.signedData.ToAsn1Object(); asn1EncodableVector2 = new Asn1EncodableVector(asn1Sequence[0], asn1Set); for (int i = 2; i != asn1Sequence.Count - 1; i++) { asn1EncodableVector2.Add(asn1Sequence[i]); } asn1EncodableVector2.Add(asn1Set2); cmsSignedData.signedData = SignedData.GetInstance(new BerSequence(asn1EncodableVector2)); cmsSignedData.contentInfo = new ContentInfo(cmsSignedData.contentInfo.ContentType, cmsSignedData.signedData); return(cmsSignedData); }
public void TestAuth() { var(privateRSAParameters, publicRSAParameters) = GenerateRSAKey(); TestAddUser("adam", publicRSAParameters); var signedData = new SignedData { Content = Encoding.UTF8.GetBytes(DateTimeOffset.UtcNow.ToUnixTimeSeconds().ToString()), PublicKey = publicRSAParameters }; signedData.GenerateSignedData(privateRSAParameters); Assert.AreEqual(HttpStatusCode.OK, TestAuthSendRequest(signedData)); signedData.Content = Encoding.UTF8.GetBytes((DateTimeOffset.UtcNow.ToUnixTimeSeconds() + 40).ToString()); signedData.GenerateSignedData(privateRSAParameters); Assert.AreEqual(HttpStatusCode.OK, TestAuthSendRequest(signedData)); var badSignedData = (SignedData)signedData.Clone(); badSignedData.SHA256Hash[0] = 0; Assert.AreEqual(HttpStatusCode.Unauthorized, TestAuthSendRequest(badSignedData)); badSignedData = (SignedData)signedData.Clone(); badSignedData.Signature[0] = 0; Assert.AreEqual(HttpStatusCode.Unauthorized, TestAuthSendRequest(badSignedData)); badSignedData = (SignedData)signedData.Clone(); badSignedData.PublicKey.Modulus[0] = 0; Assert.AreEqual(HttpStatusCode.Unauthorized, TestAuthSendRequest(badSignedData)); }
public static bool Validate(SignedData signedData) { AsymmetricKeyParameter publicKeyParameter = decodePublicKeyParameter(signedData.subjectPublicKeyInfo); AlgorithmIdentifier signatureAlgorithm = decodeSignatureAlgorithm(signedData.signatureAlgorithm); var verifier = new Asn1VerifierFactory(signatureAlgorithm, publicKeyParameter); return(verify(verifier, signatureAlgorithm, signedData.signedData, signedData.signatureValue)); }
/// <summary> /// ContentInfo with detached signature, digests precomputed in hashes. /// </summary> /// <param name="hashes">A map of precomputed digests for content indexed by name of hash.</param> /// <param name="sigData">A ContentInfo containing a signedData object.</param> public CmsSignedData( IDictionary <DerObjectIdentifier, byte[]> hashes, ContentInfo sigData) { this.hashes = hashes; this.contentInfo = sigData; this.signedData = SignedData.GetInstance(contentInfo.Content); }
/// <summary> /// ContentInfo constructor - with detached signature. /// </summary> /// <param name="signedContent">The content that was signed.</param> /// <param name="sigData">A ContentInfo containing a signedData object.</param> public CmsSignedData( ICmsTypedData signedContent, ContentInfo sigData) { this.signedContent = signedContent; this.contentInfo = sigData; this.signedData = SignedData.GetInstance(contentInfo.Content); }
public CmsSignedData( IDictionary hashes, ContentInfo sigData) { this.hashes = hashes; this.contentInfo = sigData; this.signedData = SignedData.GetInstance(contentInfo.Content); }
public static bool Validate(SignedData signedData) { return(NetCoreSignatureValidator.Validate(signedData)); //return NeoVMCoreSignatureValidator.Validate(signedData); //todo: Signature will be validated using parameter fields //now always return signature is valid //todo: add real implementation code }
public CmsSignedData( CmsProcessable signedContent, ContentInfo sigData) { this.signedContent = signedContent; this.contentInfo = sigData; this.signedData = SignedData.GetInstance(contentInfo.Content); }
public CmsSignedData(ContentInfo sigData) { contentInfo = sigData; signedData = SignedData.GetInstance(contentInfo.Content); if (signedData.EncapContentInfo.Content != null) { signedContent = new CmsProcessableByteArray(((Asn1OctetString)signedData.EncapContentInfo.Content).GetOctets()); } }
internal CallerChainImpl(string busId, LoginInfo caller, string target, LoginInfo[] originators, SignedData signed, SignedCallChain legacySigned) : this(busId, target) { Originators = originators; Caller = caller; Signed = new AnySignedChain(signed, legacySigned); Legacy = false; }
public void CreateSign() { byte[] data = File.ReadAllBytes(Path.Combine(_settings.PackagePath, _manifestFilename)); X509Certificate2 certificate = new X509Certificate2(_settings.CertificatePath, _settings.CertificatePassword, X509KeyStorageFlags.Exportable); X509Certificate2 intermCertificate = new X509Certificate2(_settings.IntermCertificatePath); var privKey = SecurityUtils.GetRsaKeyPair(certificate.GetRSAPrivateKey()).Private; var cert = SecurityUtils.FromX509Certificate(certificate); var interm = SecurityUtils.FromX509Certificate(intermCertificate); CmsProcessableByteArray content = new CmsProcessableByteArray(data); CmsSignedDataGenerator generator = new CmsSignedDataGenerator(); generator.AddSigner(privKey, cert, CmsSignedGenerator.EncryptionRsa, CmsSignedGenerator.DigestSha256); CmsSignedData signedContent = generator.Generate(content, false); var si = signedContent.GetSignerInfos(); var signer = si.GetSigners().Cast <SignerInformation>().First(); SignerInfo signerInfo = signer.ToSignerInfo(); Asn1EncodableVector digestAlgorithmsVector = new Asn1EncodableVector(); digestAlgorithmsVector.Add(new AlgorithmIdentifier( algorithm: new DerObjectIdentifier(_oidSHA256), parameters: DerNull.Instance)); // Construct SignedData.encapContentInfo ContentInfo encapContentInfo = new ContentInfo( contentType: new DerObjectIdentifier(_oidPKCS7IdData), content: null); Asn1EncodableVector certificatesVector = new Asn1EncodableVector(); certificatesVector.Add(X509CertificateStructure.GetInstance(Asn1Object.FromByteArray(cert.GetEncoded()))); certificatesVector.Add(X509CertificateStructure.GetInstance(Asn1Object.FromByteArray(interm.GetEncoded()))); // Construct SignedData.signerInfos Asn1EncodableVector signerInfosVector = new Asn1EncodableVector(); signerInfosVector.Add(signerInfo.ToAsn1Object()); // Construct SignedData SignedData signedData = new SignedData( digestAlgorithms: new DerSet(digestAlgorithmsVector), contentInfo: encapContentInfo, certificates: new BerSet(certificatesVector), crls: null, signerInfos: new DerSet(signerInfosVector)); ContentInfo contentInfo = new ContentInfo( contentType: new DerObjectIdentifier(_oidPKCS7IdSignedData), content: signedData); File.WriteAllBytes(Path.Combine(_settings.PackagePath, _signatureFilename), contentInfo.GetDerEncoded()); }
protected override void Unpack(Unpacker unpacker) { base.Unpack(unpacker); AccountId = unpacker.UnpackLong(); ChainId = unpacker.UnpackInt(); ChainIndex = unpacker.UnpackUInt(); KeyIndex = unpacker.UnpackShort(); Attachements = new SignedData <Attachements>((u) => new Attachements(u), unpacker); }
public ClientAttachementsRequestMessage(Attachements attachements, short keyIndex, Key accountKey) : this() { SetRequestCode(); Attachements = new SignedData <Attachements>(attachements, accountKey); KeyIndex = keyIndex; AccountId = attachements.AccountId; ChainId = attachements.ChainId; ChainIndex = attachements.ChainIndex; }
public void TestAddUserToGroup() { var(privateRSAParameters, publicRSAParameters) = GenerateRSAKey(); TestAddUser("adam", publicRSAParameters); var signedData = new SignedData { Content = Encoding.UTF8.GetBytes(DateTimeOffset.UtcNow.ToUnixTimeSeconds().ToString()), PublicKey = publicRSAParameters }; signedData.GenerateSignedData(privateRSAParameters); var authData = Convert.ToBase64String(Encoding.UTF8.GetBytes(JsonConvert.SerializeObject(signedData))); var request = new HttpRequestMessage(HttpMethod.Post, EndPoint + "api/group"); request.Headers.Add("Authorization", $"Bearer {authData}"); request.Content = new StringContent(JsonConvert.SerializeObject(new Group { GroupName = "test" }), Encoding.UTF8, "application/json"); var response = HttpClient.SendAsync(request).Result; response.EnsureSuccessStatusCode(); var group = JsonConvert.DeserializeObject <Group>(response.Content.ReadAsStringAsync().Result); request = new HttpRequestMessage(HttpMethod.Get, EndPoint + "api/invite/create/" + group.GroupId); request.Headers.Add("Authorization", $"Bearer {authData}"); response = HttpClient.SendAsync(request).Result; response.EnsureSuccessStatusCode(); var inviteLink = JsonConvert.DeserializeObject <GroupInviteLink>(response.Content.ReadAsStringAsync().Result); var(privateRSAParameters2, publicRSAParameters2) = GenerateRSAKey(); TestAddUser("charles", publicRSAParameters2); signedData = new SignedData { Content = Encoding.UTF8.GetBytes(DateTimeOffset.UtcNow.ToUnixTimeSeconds().ToString()), PublicKey = publicRSAParameters2 }; signedData.GenerateSignedData(privateRSAParameters2); authData = Convert.ToBase64String(Encoding.UTF8.GetBytes(JsonConvert.SerializeObject(signedData))); request = new HttpRequestMessage(HttpMethod.Get, EndPoint + $"api/invite/enter/{inviteLink.GroupInviteLinkId}/{inviteLink.InviteCode}"); request.Headers.Add("Authorization", $"Bearer {authData}"); response = HttpClient.SendAsync(request).Result; response.EnsureSuccessStatusCode(); var inviteLink2 = JsonConvert.DeserializeObject <GroupInviteLink>(response.Content.ReadAsStringAsync().Result); Assert.AreEqual(group.GroupId, inviteLink2.GroupId); request = new HttpRequestMessage(HttpMethod.Get, EndPoint + $"api/group/1"); request.Headers.Add("Authorization", $"Bearer {authData}"); response = HttpClient.SendAsync(request).Result; Console.WriteLine(response.Content.ReadAsStringAsync().Result); }
private HttpStatusCode TestAuthSendRequest(SignedData signedData) { var authData = Convert.ToBase64String(Encoding.UTF8.GetBytes(JsonConvert.SerializeObject(signedData))); var request = new HttpRequestMessage(HttpMethod.Get, EndPoint + "api/user/" + 1); request.Headers.Add("Authorization", $"Bearer {authData}"); var response = HttpClient.SendAsync(request).Result; return(response.StatusCode); }
private void CachePost(SignedData signedHeader, PostHeader header) { if (Core.InvokeRequired) Debug.Assert(false); if (header.ParentID == 0 && header.SourceID != header.TargetID) { Network.UpdateLog("Board", "Post made to board other than source's"); return; } if (!File.Exists(GetPostPath(header))) { DownloadPost(signedHeader, header); return; } // check if current version loaded OpPost post = GetPost(header); if (post != null && post.Header.Version >= header.Version ) { UpdateGui(post); return; } // put into map OpBoard board = GetBoard(header.TargetID); if (board == null) { board = new OpBoard(header.Target); BoardMap.SafeAdd(header.TargetID, board); } PostUID uid = new PostUID(header); post = new OpPost(); post.Header = header; post.SignedHeader = signedHeader.Encode(Network.Protocol); post.Ident = header.TargetID.GetHashCode() ^ uid.GetHashCode(); post.Unique = Loading; // remove previous version of file, if its different OpPost prevPost = board.GetPost(uid); if (prevPost != null && GetPostPath(prevPost.Header) != GetPostPath(header)) try { File.Delete(GetPostPath(prevPost.Header)); } catch { } board.Posts.SafeAdd(uid, post); // update replies if (post.Header.ParentID == 0) board.UpdateReplies(post); else { PostUID parentUid = new PostUID(board.UserID, post.Header.ProjectID, post.Header.ParentID); OpPost parentPost = board.GetPost(parentUid); if (parentPost != null) { board.UpdateReplies(parentPost); UpdateGui(post); } } lock (SaveHeaders) if (!SaveHeaders.Contains(header.TargetID)) SaveHeaders.Add(header.TargetID); ushort replies = 0; if (SavedReplyCount.SafeTryGetValue(post.Ident, out replies)) { post.Replies = replies; SavedReplyCount.SafeRemove(post.Ident); } UpdateGui(post); if (Core.NewsWorthy(header.TargetID, header.ProjectID, true)) Core.MakeNews(ServiceIDs.Board, "Board updated by " + Core.GetName(header.SourceID), header.SourceID, 0, false); }
void DownloadPost(SignedData signed, PostHeader header) { if (!Utilities.CheckSignedData(header.Source, signed.Data, signed.Signature)) return; FileDetails details = new FileDetails(ServiceID, 0, header.FileHash, header.FileSize, new PostUID(header).ToBytes()); Core.Transfers.StartDownload(header.TargetID, details, GetPostPath(header), new EndDownloadHandler(EndDownload), new object[] { signed, header }); }
private void Process_PostHeader(DataReq data, SignedData signed, PostHeader header) { Core.IndexKey(header.SourceID, ref header.Source); Core.IndexKey(header.TargetID, ref header.Target); PostUID uid = new PostUID(header); OpPost current = GetPost(header.TargetID, uid); // if link loaded if (current != null) { // lower version, send update if (header.Version < current.Header.Version) { if (data != null && data.Source != null) Store.Send_StoreReq(data.Source, data.LocalProxy, new DataReq(null, header.TargetID, ServiceID, 0, current.SignedHeader)); return; } // higher version else if (header.Version > current.Header.Version) { CachePost(signed, header); } // equal version do nothing } // else load file, set new header after file loaded else CachePost(signed, header); }
private void Process_ProjectData(OpTrust trust, SignedData signed, ProjectData project) { if (!Utilities.CheckSignedData(trust.File.Key, signed.Data, signed.Signature)) return; if (project.ID != 0 && !ProjectNames.SafeContainsKey(project.ID)) ProjectNames.SafeAdd(project.ID, project.Name); trust.AddProject(project.ID, true); if (project.ID == 0) { trust.Name = project.UserName; Core.IndexName(trust.UserID, trust.Name); } OpLink link = trust.GetLink(project.ID); }
private void Process_VersionedFile(DataReq data, SignedData signed, VersionedFileHeader header) { Core.IndexKey(header.KeyID, ref header.Key); OpVersionedFile current = GetFile(header.KeyID); // if link loaded if (current != null) { // lower version if (header.Version < current.Header.Version) { if (data != null && data.Source != null) Store.Send_StoreReq(data.Source, data.LocalProxy, new DataReq(null, current.UserID, Service, DataType, current.SignedHeader)); return; } // higher version else if (header.Version > current.Header.Version) { CacheFile(signed, header); } } // else load file, set new header after file loaded else CacheFile(signed, header); }
private void Download(SignedData signed, VersionedFileHeader header) { if (!Utilities.CheckSignedData(header.Key, signed.Data, signed.Signature)) { Debug.Assert(false); return; } FileDetails details = new FileDetails(Service, DataType, header.FileHash, header.FileSize, null); Core.Transfers.StartDownload(header.KeyID, details, GetFilePath(header), new EndDownloadHandler(EndDownload), new object[] { signed, header } ); }
private void CacheFile(SignedData signedHeader, VersionedFileHeader header) { if (Core.InvokeRequired) Debug.Assert(false); try { // check if file exists string path = ""; if (header.FileHash != null) { path = GetFilePath(header); if (!File.Exists(path)) { Download(signedHeader, header); return; } } // get file OpVersionedFile prevFile = GetFile(header.KeyID); if (prevFile != null) if (header.Version < prevFile.Header.Version) return; // dont update with older version OpVersionedFile newFile = new OpVersionedFile(header.Key); // set new header newFile.Header = header; newFile.SignedHeader = signedHeader.Encode(Network.Protocol); newFile.Unique = !Network.Established; FileMap.SafeAdd(header.KeyID, newFile); RunSaveHeaders = true; if(FileAquired != null) FileAquired.Invoke(newFile); // delete old file - do after aquired event so invoked (storage) can perform clean up operation if (prevFile != null && prevFile.Header.FileHash != null) { string oldPath = GetFilePath(prevFile.Header); if (path != oldPath && File.Exists(oldPath)) try { File.Delete(oldPath); } catch { } } } catch (Exception ex) { Core.Network.UpdateLog("VersionedFile", "Error caching data " + ex.Message); } }
private void Process_UplinkReq(DataReq data, SignedData signed, UplinkRequest request) { Core.IndexKey(request.KeyID, ref request.Key); Core.IndexKey(request.TargetID, ref request.Target); if (!Utilities.CheckSignedData(request.Key, signed.Data, signed.Signature)) return; OpTrust requesterTrust = GetTrust(request.KeyID); if (requesterTrust != null && requesterTrust.Loaded && requesterTrust.File.Header.Version > request.LinkVersion) return; // check if target in linkmap, if not add OpTrust targetTrust = GetTrust(request.TargetID); if (targetTrust == null) { targetTrust = new OpTrust(new OpVersionedFile(request.Target) ); TrustMap.SafeAdd(request.TargetID, targetTrust); } if (targetTrust.Loaded && targetTrust.File.Header.Version > request.TargetVersion) return; request.Signed = signed.Encode(Network.Protocol); // so we can send it in results / save, later on // check for duplicate requests OpLink targetLink = targetTrust.GetLink(request.ProjectID); if (targetLink != null) { foreach (UplinkRequest compare in targetLink.Requests) if (Utilities.MemCompare(compare.Signed, request.Signed)) return; } else { targetTrust.AddProject(request.ProjectID, true); targetLink = targetTrust.GetLink(request.ProjectID); } // add targetLink.Requests.Add(request); // if target is marked as linked or focused, update link of target and sender if (targetTrust.Loaded && (targetTrust.InLocalLinkTree || Core.KeepData.SafeContainsKey(targetTrust.UserID))) { if (targetTrust.File.Header.Version < request.TargetVersion) Cache.Research(targetTrust.UserID); if (requesterTrust == null) { requesterTrust = new OpTrust(new OpVersionedFile(request.Key)); TrustMap.SafeAdd(request.KeyID, requesterTrust); } // once new version of requester's link file has been downloaded, interface will be updated if (!requesterTrust.Loaded || (requesterTrust.File.Header.Version < request.LinkVersion)) Cache.Research(requesterTrust.UserID); } RunSaveUplinks = true; }
private void Process_LinkData(OpTrust trust, SignedData signed, LinkData linkData) { if (!Utilities.CheckSignedData(trust.File.Key, signed.Data, signed.Signature)) return; Core.IndexKey(linkData.TargetID, ref linkData.Target); uint project = linkData.Project; OpLink localLink = trust.GetLink(project); if (localLink == null) return; OpTrust targetTrust = GetTrust(linkData.TargetID, false); if (targetTrust == null) { targetTrust = new OpTrust(new OpVersionedFile(linkData.Target)); TrustMap.SafeAdd(linkData.TargetID, targetTrust); } targetTrust.AddProject(project, false); OpLink targetLink = targetTrust.GetLink(project); if (linkData.Uplink) { localLink.Uplink = targetLink; targetLink.Downlinks.Add(localLink); // always know a link's trust structure to the top if (!targetTrust.Loaded) Cache.Research(targetTrust.UserID); //if (targetLink.Uplink == null) // AddRoot(targetLink); } else { if (linkData.Title != null) localLink.Titles[targetLink.UserID] = linkData.Title; localLink.Confirmed.Add(targetLink.UserID); } }