public void Init() { _view.Render(); while (true) { var message = KeyReader.Read(Console.ReadKey(true)); if (message.Body == "quit") { break; } if (message.Header == "error") { continue; } _model.InputBuffer.Send(message); if (_model.CurrentTurnMessages != null) { _model.CurrentTurnMessages.ToList().ForEach(msg => Console.WriteLine(String.Format("The {0} {1} from {2}, to {3}", msg.Name, msg.Type, msg.From, msg.To))); } } }
public void ReadPublicKeyFromPKCS12() { RSA rsa = KeyReader.ReadPublicKey(PFX_PATH, PFX_PASSWORD); Assert.IsNotNull(rsa); rsa.Dispose(); }
private bool HasJoinKeyOverride(NewReader reader, KeyReader joinKey) { IReference childReference = joinKey.Reference.Find(ReferenceFlags.Child); IReferenceMetadata targetMetadata = childReference.List ?? childReference.Metadata; return(reader.Properties.Any(r => r.Metadata.Identity.Equals(targetMetadata.Identity))); }
public void ReadKey(string keyId, Domain domain, string keyName, Type dataType, object defaultVal, string inputStr) { //<key id="nd0" for="node" attr.name="X1" attr.type="string" /> var keyReader = new KeyReader(); var reader = new XmlTextReader(new StringReader(inputStr)); reader.Read(); Assert.True(reader.IsStartElement()); Assert.True(string.Compare("key", reader.Name, true) == 0, string.Format("Reader.Name should match expected, not: \"{0}\"", reader.Name)); string retrievedKeyId; Domain retrievedDomain; string retrievedAttribName; Type retrievedType; object retrievedDefault; keyReader.Read(out retrievedKeyId, out retrievedDomain, out retrievedAttribName, out retrievedType, out retrievedDefault, reader); Assert.Equal(keyId, retrievedKeyId); Assert.Equal(domain, retrievedDomain); Assert.Equal(keyName, retrievedAttribName); Assert.Equal(dataType, retrievedType); Assert.Equal(defaultVal, retrievedDefault); if (!reader.IsEmptyElement) Assert.True(string.Compare("key", reader.Name, true) == 0, string.Format("End Reader.Name should match expected, not: \"{0}\"", reader.Name)); }
private void InitializeKey(KeyReader key) { if (key.Reference != null) { foreach (DataReader value in key.Values) { value.KeyType = value.Metadata.Type.GetKeyType(); } key.KeyType = CompositeKey.Create(key.Values.Select(v => v.KeyType)); if (key.Values.Count > 1) { key.Variable = Expression.Variable(key.KeyType); } if (key.Reference.HasFlag(ReferenceFlags.Self)) { key.Reference = this.GetRecursiveReference(key.Reference); } } foreach (DataReader value in key.Values) { value.IsDbNull ??= this.GetNamedVariable(typeof(bool), value, "_isnull"); value.Variable ??= this.GetNamedVariable(value.KeyType, value); } }
public void ReadPublicKeyFromPem() { RSA rsa = KeyReader.ReadPublicKey(PEM_PATH, null); Assert.IsNotNull(rsa); rsa.Dispose(); }
public byte[] EncriptData() { RSA pkeyid = KeyReader.ReadPrivateKeyFromPKCS12(PFX_PATH, PFX_PASSWORD); byte[] data = pkeyid.Encrypt(Encoding.Default.GetBytes(DATA), RSAEncryptionPadding.Pkcs1); pkeyid.Dispose(); Assert.IsNotNull(data); return(data); }
public byte[] SignData() { RSA pkeyid = KeyReader.ReadPrivateKeyFromPKCS12(PFX_PATH, PFX_PASSWORD); byte[] signature = pkeyid.SignData(Encoding.Default.GetBytes(DATA), HashAlgorithmName.SHA1, RSASignaturePadding.Pkcs1); pkeyid.Dispose(); Assert.IsNotNull(signature); return(signature); }
public void VerifyData() { RSA cert = KeyReader.ReadPublicKey(PEM_PATH, null); byte[] signature = SignData(); Assert.IsTrue(cert.VerifyData(Encoding.Default.GetBytes(DATA), signature, HashAlgorithmName.SHA1, RSASignaturePadding.Pkcs1)); cert.Dispose(); }
public void DecriptData() { RSA pkeyid = KeyReader.ReadPrivateKeyFromPKCS12(PFX_PATH, PFX_PASSWORD); byte[] data = EncriptData(); byte[] decripted = pkeyid.Decrypt(data, RSAEncryptionPadding.Pkcs1); pkeyid.Dispose(); Assert.AreEqual(DATA, Encoding.Default.GetString(decripted)); }
public void ConvertDefaultValStr(string defaultValStr, object expectedResult, Type valType) { var keyReader = new KeyReader(); var result = keyReader.ConvertDefaultValStr(defaultValStr, valType); if (defaultValStr!=null) { Assert.NotNull(result); Assert.Equal(valType, result.GetType()); Assert.Equal(expectedResult, result); } }
private static GoogleOAuth2AuthenticationOptions GetGoogleOptions() { var reader = new KeyReader(); var keys = reader.GetKey("google"); var options = new GoogleOAuth2AuthenticationOptions() { ClientId = keys.Public, ClientSecret = keys.Private }; return(options); }
private static FacebookAuthenticationOptions GetFacebookOptions() { var reader = new KeyReader(); var keys = reader.GetKey("facebook"); var options = new FacebookAuthenticationOptions() { AppId = keys.Public, AppSecret = keys.Private }; options.Scope.Add("email"); return(options); }
static void Main(string[] args) { var consoleArgs = new ConsoleArguments(args); if (consoleArgs.ContainsSwitch("-h") || consoleArgs.ContainsSwitch("-?") || args.Length <= 0) { PrintHelp(); return; } var p = new Dictionary <string, string>(); p["key"] = consoleArgs.GetSwitchValue("-k"); p["account"] = consoleArgs.GetSwitchValue("-a"); p["share"] = consoleArgs.GetSwitchValue("-s"); p["dir"] = consoleArgs.GetSwitchValue("-d"); if (p.Values.Any(string.IsNullOrWhiteSpace)) { PrintHelp(); return; } var logger = new ConsoleLogger(); var keys = new KeyReader(p["key"]); var dir = new DirectoryInfo(p["dir"]); if (!dir.Exists) { throw new ArgumentException(string.Format("Invalid directory {0}", p["dir"])); } var sw = Stopwatch.StartNew(); var dirSync = new DirectorySync(keys.GetByAccountName(p["account"]), p["share"], dir, logger) { RunAsync = consoleArgs.ContainsSwitch("-async") }; if (consoleArgs.ContainsSwitch("-deleteAll")) { dirSync.DeleteAll(); } else if (consoleArgs.ContainsSwitch("-force")) { dirSync.CleanAndDownload(); } else { dirSync.Sync(); } sw.Stop(); logger.WriteLine(""); logger.WriteLine("FINISH THE SYNC IN {0}", sw.Elapsed); }
private static void ReadEncryptedPkcs8 <TRet>( string[] validOids, ReadOnlyMemory <byte> source, ReadOnlySpan <char> password, ReadOnlySpan <byte> passwordBytes, KeyReader <TRet> keyReader, out int bytesRead, out TRet ret) { int read; EncryptedPrivateKeyInfoAsn epki; try { AsnValueReader reader = new AsnValueReader(source.Span, AsnEncodingRules.BER); read = reader.PeekEncodedValue().Length; EncryptedPrivateKeyInfoAsn.Decode(ref reader, source, out epki); } catch (AsnContentException e) { throw new CryptographicException(SR.Cryptography_Der_Invalid_Encoding, e); } // No supported encryption algorithms produce more bytes of decryption output than there // were of decryption input. byte[] decrypted = CryptoPool.Rent(epki.EncryptedData.Length); Memory <byte> decryptedMemory = decrypted; try { int decryptedBytes = PasswordBasedEncryption.Decrypt( epki.EncryptionAlgorithm, password, passwordBytes, epki.EncryptedData.Span, decrypted); decryptedMemory = decryptedMemory.Slice(0, decryptedBytes); ReadPkcs8( validOids, decryptedMemory, keyReader, out int innerRead, out ret); if (innerRead != decryptedMemory.Length) { ret = default !;
public void ReadDefault(string expectedVal, string inputStr) { var keyReader = new KeyReader(); var reader = new XmlTextReader(new StringReader(inputStr)); reader.Read(); Assert.True(reader.IsStartElement()); Assert.True(string.Compare("default", reader.Name, true) == 0, string.Format( "Reader.Name should match expected, not: \"{0}\"", reader.Name)); string defalutValStr; keyReader.ReadDefault(out defalutValStr, reader); Assert.Equal(expectedVal, defalutValStr); if (!reader.IsEmptyElement) Assert.True(string.Compare("default", reader.Name, true) == 0, string.Format("End Reader.Name should match expected, not: \"{0}\"", reader.Name)); }
internal static unsafe void ReadEncryptedPkcs8 <TRet>( string[] validOids, ReadOnlySpan <byte> source, ReadOnlySpan <char> password, KeyReader <TRet> keyReader, out int bytesRead, out TRet ret) { fixed(byte *ptr = &MemoryMarshal.GetReference(source)) { using (MemoryManager <byte> manager = new PointerMemoryManager <byte>(ptr, source.Length)) { ReadEncryptedPkcs8(validOids, manager.Memory, password, keyReader, out bytesRead, out ret); } } }
private static void ReadEncryptedPkcs8 <TRet>( string[] validOids, ReadOnlyMemory <byte> source, ReadOnlySpan <byte> passwordBytes, KeyReader <TRet> keyReader, out int bytesRead, out TRet ret) { ReadEncryptedPkcs8( validOids, source, ReadOnlySpan <char> .Empty, passwordBytes, keyReader, out bytesRead, out ret); }
private ParameterExpression GetListVariable(IBindingMetadata metadata, KeyReader joinKey) { if (joinKey != null) { Type dictType = typeof(Dictionary <,>).MakeGenericType(joinKey.KeyType, typeof(ElasticArray)); return(this.GetNamedVariable(dictType, metadata.Identity)); } else if (metadata.HasFlag(BindingMetadataFlags.Item)) { Type listType = metadata.Parent.Composition?.Construct?.Type ?? throw BindingException.InvalidConstructor(metadata.Parent); return(this.GetNamedVariable(listType, metadata.Identity)); } return(null); }
private void AddChildKey(ListResult result, TargetWriter writer) { IList <IReference> references = this.GetChildReferences(writer.Source.Metadata).ToList(); KeyReader childKey = references.Select(r => this.FindChildKey(writer.Source, r)).NotNull().FirstOrDefault(); if (childKey != null && this.IsValidJoinKey(childKey, throwOnInvalid: true)) { this.InitializeKey(childKey); } if (childKey == null && this.RequiresReference(writer.Source.Metadata)) { throw BindingException.NoReferenceFound(writer.Source.Metadata); } writer.List = this.GetListTarget(result, writer.Source.Metadata, childKey); writer.Join = this.GetJoinTarget(result, childKey); }
private bool IsValidJoinKey(KeyReader joinKey, bool throwOnInvalid = false) { IReferenceKey parentKey = joinKey.Reference.FindParentKey(); IReferenceKey childKey = joinKey.Reference.FindChildKey(); foreach (var(childValue, parentValue) in childKey.Properties.Zip(parentKey.Properties)) { Type parentType = parentValue.Type.GetKeyType(); Type childType = childValue.Type.GetKeyType(); if (parentType != childType && throwOnInvalid) { throw BindingException.InvalidReference(joinKey.Reference); } else if (parentType != childType) { return(false); } } return(true); }
private JoinTarget GetJoinTarget(ListResult result, KeyReader joinKey) { if (joinKey == null) { return(null); } ListTarget list = this.GetListTarget(result, joinKey.Target, joinKey); JoinTarget target = new JoinTarget() { Key = joinKey, Buffer = Expression.Variable(typeof(ElasticArray), "_joinbuf"), Index = this.Buffer.GetJoinIndex(joinKey.Reference), List = list, }; if (joinKey.Target.HasFlag(BindingMetadataFlags.Item)) { target.NewList = joinKey.Target.Parent.Composition.Construct; target.AddMethod = joinKey.Target.Parent.Composition.Add; } return(target); }
public static Node GetSyntaxProcessorLinkedList() { IDataReader keyReader = new KeyReader(); IDataReader valueReader = new ValueReader(); Node root = new Node(new OneWordSyntaxValidator(Constants.Draw), keyReader); Node temp = root.NextNode = new Node(new WordListSyntaxValidator(new HashSet <string> { "a", "an" }), null); temp = temp.NextNode = new Node(new ShapeNameSyntaxValidator(), valueReader); temp = temp.NextNode = new Node(new OneWordSyntaxValidator("with"), null); var loopNode = temp = temp.NextNode = new Node(new WordListSyntaxValidator(new HashSet <string> { "a", "an" }), null); temp = temp.NextNode = new Node(new MeasurementNameSyntaxValidator(), keyReader); temp = temp.NextNode = new Node(new OneWordSyntaxValidator("of"), null); temp = temp.NextNode = new Node(new IntegerSyntaxValidator(), valueReader); temp = temp.NextNode = new Node(new OneWordSyntaxValidator("and"), null); temp.NextNode = loopNode; return(root); }
private ListTarget GetListTarget(ListResult result, IBindingMetadata metadata, KeyReader joinKey) { int bufferIndex = this.Buffer.GetListIndex(metadata, joinKey?.Reference); metadata = joinKey?.Target ?? metadata; ListTarget target = result.Targets.FirstOrDefault(t => t.Index == bufferIndex); if (target != null) { return(target); } target = new ListTarget() { Index = bufferIndex, Variable = this.GetListVariable(metadata, joinKey), }; if (joinKey == null && metadata.HasFlag(BindingMetadataFlags.Item)) { target.NewList = target.NewTarget = metadata.Parent.Composition?.Construct ?? throw BindingException.InvalidConstructor(metadata.Parent); target.AddMethod = metadata.Parent.Composition.Add; } if (joinKey != null) { target.NewTarget = Expression.New(target.Variable.Type); } if (target.NewTarget != null) { result.Targets.Add(target); } return(target); }
public void ReadKey_And_Veryfy_Type(Type expectedKeyType, string keyId, Domain domain, string keyName, Type dataType, object defaultVal, string inputStr) { var keyReader = new KeyReader(); var reader = new XmlTextReader(new StringReader(inputStr)); reader.Read(); Assert.True(reader.IsStartElement()); Assert.True(string.Compare("key", reader.Name, true) == 0, string.Format("Reader.Name should match expected, not: \"{0}\"", reader.Name)); Key key = null; keyReader.Read(out key, reader); Assert.NotNull(key); Assert.Equal(expectedKeyType, key.GetType()); Assert.Equal(keyId, key.Id); Assert.Equal(domain, key.Domain); Assert.Equal(keyName, key.Name); Assert.Equal(dataType, key.DataType); if (defaultVal!=null) Assert.Equal(defaultVal.ToString(), key.DefaultString); if (!reader.IsEmptyElement) Assert.True(string.Compare("key", reader.Name, true) == 0, string.Format("End Reader.Name should match expected, not: \"{0}\"", reader.Name)); }
public static async Task <string> Run(SignOptions options) { var serviceProvider = new ServiceCollection() .AddHttpMessageSigning() .BuildServiceProvider(); var requestSignerFactory = serviceProvider.GetRequiredService <IRequestSignerFactory>(); ISignatureAlgorithm signatureAlgorithm; if (string.IsNullOrEmpty(options.KeyType) || options.KeyType.Equals("RSA", StringComparison.OrdinalIgnoreCase)) { signatureAlgorithm = RSASignatureAlgorithm.CreateForSigning(HashAlgorithmName.SHA512, KeyReader.ReadRSA(options.PrivateKey)); } else if (options.KeyType.Equals("P256", StringComparison.OrdinalIgnoreCase) || options.KeyType.Equals("ECDSA", StringComparison.OrdinalIgnoreCase)) { signatureAlgorithm = ECDsaSignatureAlgorithm.CreateForSigning(HashAlgorithmName.SHA512, KeyReader.ReadECDsaPrivate(options.PrivateKey)); } else if (options.KeyType.Equals("HMAC", StringComparison.OrdinalIgnoreCase)) { signatureAlgorithm = SignatureAlgorithm.CreateForSigning(options.PrivateKey, HashAlgorithmName.SHA512); } else { throw new NotSupportedException("The specified key type is not supported."); } if (!string.IsNullOrEmpty(options.Algorithm) && !options.Algorithm.StartsWith("rsa", StringComparison.OrdinalIgnoreCase) && !options.Algorithm.StartsWith("hmac", StringComparison.OrdinalIgnoreCase) && !options.Algorithm.StartsWith("ecdsa", StringComparison.OrdinalIgnoreCase)) { signatureAlgorithm = new CustomSignatureAlgorithm(options.Algorithm); } var signingSettings = new SigningSettings { SignatureAlgorithm = signatureAlgorithm, EnableNonce = false, DigestHashAlgorithm = HashAlgorithmName.SHA256, AutomaticallyAddRecommendedHeaders = false, Headers = options.Headers ?.Split(new[] { ' ', ',' }, StringSplitOptions.RemoveEmptyEntries) .Select(h => new HeaderName(h)) .ToArray() }; var signer = requestSignerFactory.Create( new KeyId("test"), signingSettings); var created = DateTimeOffset.UtcNow; if (!string.IsNullOrEmpty(options.Created)) { var createdUnix = int.Parse(options.Created); created = DateTimeOffset.FromUnixTimeSeconds(createdUnix); } var expires = signingSettings.Expires; if (!string.IsNullOrEmpty(options.Expires)) { var expiresUnix = int.Parse(options.Expires); var expiresAbsolute = DateTimeOffset.FromUnixTimeSeconds(expiresUnix); expires = expiresAbsolute - created; } await signer.Sign(options.Message, created, expires); var serializedMessage = HttpMessageSerializer.Serialize(options.Message); return(serializedMessage); }
static void Main(string[] args) { IQueue queue = new AzurePrintsQueue(); IStorage storage = new AzurePrintsStorage(); IKeyReader reader = new KeyReader(); Execute(queue, storage, reader); }
public UserController() { _userService = new UserService(new UserRepository(new AesEncryptor(KeyReader.Instance().GetKey())), new AuthenticatorFactory(), new UserMapper(new AesEncryptor(KeyReader.Instance().GetKey()))); }
void ParseAnimator(Node node) { IAnimator animator = null; string type = lexer.ParseQuotedString(); frames.Clear(); functions.Clear(); values.Clear(); lexer.ParseToken('{'); string propertyName = ""; string className = ""; while (lexer.PeekChar() != '}') { var name = lexer.ParseWord(); switch (name) { case "Property": string[] s = lexer.ParseQuotedString().Split('@'); propertyName = s[0]; className = s[1]; switch (propertyName) { case "AlongTrackOrientation": propertyName = "AlongPathOrientation"; break; case "File": propertyName = "Sample"; break; case "TexCoordForMins": propertyName = "UV0"; break; case "TexCoordForMaxs": propertyName = "UV1"; break; case "WidgetName": propertyName = "WidgetId"; break; case "TexturePath": propertyName = "Texture"; break; case "Anchor": propertyName = "Position"; break; case "BlendMode": propertyName = "Blending"; break; case "AnimationFPS": propertyName = "AnimationFps"; break; case "Life": propertyName = "Lifetime"; break; case "FontSize": propertyName = "FontHeight"; break; case "HAlign": propertyName = "HAlignment"; break; case "VAlign": propertyName = "VAlignment"; break; case "SplineName": propertyName = "SplineId"; break; case "RandMotionRadius": propertyName = "RandomMotionRadius"; break; case "RandMotionRotation": propertyName = "RandomMotionRotation"; break; case "RandMotionSpeed": propertyName = "RandomMotionSpeed"; break; case "RandMotionAspectRatio": propertyName = "RandomMotionAspectRatio"; break; case "TextColor": propertyName = "TextColor"; break; } switch (propertyName + '@' + className) { case "ShadowColor@Hot::Text": case "TextColor@Hot::TextPresenter": case "ShadowColor@Hot::TextPresenter": animator = new Color4Animator(); break; case "Blending@Hot::MaskedEffect": animator = new Animator <Blending>(); break; case "AlongTrackOrientation@Hot::ParticleEmitter": animator = new Animator <bool>(); break; case "WidgetId@Hot::Gear": animator = new Animator <NodeReference <Widget> >(); break; case "SplineId@Hot::Gear": animator = new Animator <NodeReference <Spline> >(); break; case "AspectRatio@Hot::ParticleTemplate": case "Scale@Hot::ParticleTemplate": animator = new NumericAnimator(); break; default: animator = node.Animators[propertyName]; break; } break; case "Frames": lexer.ParseToken('['); while (lexer.PeekChar() != ']') { if (!isTangerine) { frames.Add(lexer.ParseInt() * 2); } else { frames.Add(lexer.ParseInt()); } } lexer.ParseToken(']'); break; case "Attributes": lexer.ParseToken('['); while (lexer.PeekChar() != ']') { functions.Add((KeyFunction)lexer.ParseInt()); } lexer.ParseToken(']'); break; case "Keys": KeyReader keyReader = GetKeyReader(type, propertyName, className); lexer.ParseToken('['); while (lexer.PeekChar() != ']') { values.Add(keyReader()); } lexer.ParseToken(']'); break; default: throw new Lime.Exception("Unknown property '{0}'. Parsing: {1}", name, animator); } } lexer.ParseToken('}'); if (values.Count > 0 && values[0] is Tuple <Blending, ShaderId> ) { ProcessBlendingAndShaderAnimators(node, animator); } else { for (int i = 0; i < frames.Count; i++) { animator.Keys.Add(frames[i], values[i], functions[i]); } } switch (propertyName + '@' + className) { case "AspectRatio@Hot::ParticleTemplate": particleModifierAspectRatioAnimator = animator as NumericAnimator; break; case "Scale@Hot::ParticleTemplate": particleModifierScaleAnimator = animator as NumericAnimator; break; } if (animator.ReadonlyKeys.Count == 0) { node.Animators.Remove(animator); } }
public static async Task <bool> Run(VerifyOptions options) { ISignatureAlgorithm signatureAlgorithm; if (string.IsNullOrEmpty(options.KeyType) || options.KeyType.Equals("RSA", StringComparison.OrdinalIgnoreCase)) { signatureAlgorithm = RSASignatureAlgorithm.CreateForVerification(HashAlgorithmName.SHA512, KeyReader.ReadRSA(options.PublicKey)); } else if (options.KeyType.Equals("P256", StringComparison.OrdinalIgnoreCase) || options.KeyType.Equals("ECDSA", StringComparison.OrdinalIgnoreCase)) { signatureAlgorithm = ECDsaSignatureAlgorithm.CreateForVerification(HashAlgorithmName.SHA512, KeyReader.ReadECDsaPublic(options.PublicKey)); } else if (options.KeyType.Equals("HMAC", StringComparison.OrdinalIgnoreCase)) { signatureAlgorithm = SignatureAlgorithm.CreateForVerification(options.PublicKey, HashAlgorithmName.SHA512); } else { throw new NotSupportedException("The specified key type is not supported."); } var serviceProvider = new ServiceCollection() .AddHttpMessageSignatureVerification(provider => { var clientStore = new InMemoryClientStore(); clientStore.Register(new Client( new KeyId("test"), "ConformanceClient", signatureAlgorithm, TimeSpan.FromSeconds(30), TimeSpan.FromMinutes(1))); return(clientStore); }) .BuildServiceProvider(); var verifier = serviceProvider.GetRequiredService <IRequestSignatureVerifier>(); var verificationResult = await verifier.VerifySignature(options.Message, new SignedRequestAuthenticationOptions { OnSignatureParsed = options.ModifyParsedSignature }); return(verificationResult is RequestSignatureVerificationResultSuccess); }