private static void CheckHeader(SignatureHeader header, SignatureKind expectedKind) { if (header.Kind != expectedKind) { throw new BadImageFormatException(SR.Format(SR.UnexpectedSignatureHeader, expectedKind, header.Kind, header.RawValue)); } }
private void CheckHeader(SignatureHeader header, SignatureKind expectedKind) { if (header.Kind != expectedKind) { throw new BadImageFormatException(StarkPlatform.Reflection.Resources.SR.Format(SR.UnexpectedSignatureHeader, expectedKind, header.Kind, header.RawValue)); } }
private static void CheckMethodOrPropertyHeader(SignatureHeader header) { SignatureKind kind = header.Kind; if (kind != SignatureKind.Method && kind != SignatureKind.Property) { throw new BadImageFormatException(SR.Format(SR.UnexpectedSignatureHeader2, SignatureKind.Property, SignatureKind.Method, header.Kind, header.RawValue)); } }
private void CheckMethodOrPropertyHeader(SignatureHeader header) { SignatureKind kind = header.Kind; if (kind != SignatureKind.Method && kind != SignatureKind.Property) { throw new BadImageFormatException(StarkPlatform.Reflection.Resources.SR.Format(SR.UnexpectedSignatureHeader2, SignatureKind.Property, SignatureKind.Method, header.Kind, header.RawValue)); } }
private void CheckHeader(SignatureHeader header, SignatureKind expectedKind) { if (header.Kind != expectedKind) { #if SRM throw new BadImageFormatException(SR.Format(SR.UnexpectedSignatureHeader, expectedKind, header.Kind, header.RawValue)); #else throw new BadImageFormatException(); #endif } }
/// <summary> /// Initializes a new instance of the <see cref="FunctionSignatureBuilder" /> class. /// </summary> /// <param name="functionSignature">The signature.</param> public FunctionSignatureBuilder([NotNull] Function functionSignature) { _newName = functionSignature.Name; _newNativeEntrypoint = functionSignature.NativeName; _newCategory = functionSignature.Categories; _newExtension = functionSignature.ExtensionName; _newAttributes = functionSignature.Attributes; _newParameters = functionSignature.Parameters; _newReturnType = functionSignature.ReturnType; _newGenericTypeParameters = functionSignature.GenericTypeParameters; _newDoc = functionSignature.Doc; _newAccessibility = functionSignature.Accessibility; _newKind = functionSignature.Kind; }
internal unsafe Signature(AsnEncodedData data, SignatureKind kind) { Kind = kind; fixed(byte *pin = data.RawData) { EncodingType encodingType; CryptQueryContentType contentType; CryptQueryFormatType formatType; CryptMsgSafeHandle msgHandle; var blob = new CRYPTOAPI_BLOB { cbData = (uint)data.RawData.Length, pbData = new IntPtr(pin) }; var result = Crypt32.CryptQueryObject( CryptQueryObjectType.CERT_QUERY_OBJECT_BLOB, ref blob, CryptQueryContentFlagType.CERT_QUERY_CONTENT_FLAG_ALL, CryptQueryFormatFlagType.CERT_QUERY_FORMAT_FLAG_BINARY, CryptQueryObjectFlags.NONE, out encodingType, out contentType, out formatType, IntPtr.Zero, out msgHandle, IntPtr.Zero); if (!result) { msgHandle.Dispose(); throw new InvalidOperationException("Unable to read signature."); } var signerSize = 0u; if (!Crypt32.CryptMsgGetParam(msgHandle, CryptMsgParamType.CMSG_SIGNER_INFO_PARAM, 0, LocalBufferSafeHandle.Zero, ref signerSize)) { throw new InvalidOperationException(); } using (var signerHandle = LocalBufferSafeHandle.Alloc(signerSize)) { if (!Crypt32.CryptMsgGetParam(msgHandle, CryptMsgParamType.CMSG_SIGNER_INFO_PARAM, 0, signerHandle, ref signerSize)) { throw new InvalidOperationException(); } InitFromHandles(msgHandle, signerHandle); } } }
public static IEnumerable <ISignature> VisitAll(this ISignature signature, SignatureKind kind) { foreach (var nested in signature.GetNestedSignatures()) { if ((nested.Kind & kind) > 0) { yield return(nested); foreach (var nestVisit in nested.VisitAll(kind)) { yield return(nestVisit); } } else if ((kind & SignatureKind.Deep) == SignatureKind.Deep) { foreach (var nestVisit in nested.VisitAll(kind)) { yield return(nestVisit); } } } }
public static void WriteSignature(this BinaryWriter writer, Signature signature) { SignatureKind kind = signature != null ? signature.Kind : SignatureKind.None; writer.Write((byte)kind); switch (signature.Kind) { case SignatureKind.Ed25519: writer.WriteByteArray(((Ed25519Signature)signature).Bytes); break; case SignatureKind.Ring: var rs = (RingSignature)signature; writer.WriteBigInteger(rs.Y0); writer.WriteBigInteger(rs.S); writer.WriteVarInt(rs.C.Length); foreach (var entry in rs.C) { writer.WriteBigInteger(entry); } break; } }
private static unsafe Entry CacheMiss(IntPtr context, IntPtr signature, SignatureKind signatureKind = SignatureKind.GenericDictionary, object contextObject = null) { IntPtr result = IntPtr.Zero, auxResult = IntPtr.Zero; bool previouslyCached = false; // // Try to find the entry in the previous version of the cache that is kept alive by weak reference // if (s_previousCache.IsAllocated) { Entry[] previousCache = (Entry[])s_previousCache.Target; if (previousCache != null) { Entry previousEntry = LookupInCache(previousCache, context, signature); if (previousEntry != null) { result = previousEntry.Result; auxResult = previousEntry.AuxResult; previouslyCached = true; } } } // // Call into the type loader to compute the target // if (!previouslyCached) { switch (signatureKind) { case SignatureKind.GenericDictionary: result = RuntimeAugments.TypeLoaderCallbacks.GenericLookupFromContextAndSignature(context, signature, out auxResult); break; case SignatureKind.GenericVirtualMethod: result = Internal.Runtime.CompilerServices.GenericVirtualMethodSupport.GVMLookupForSlot(new RuntimeTypeHandle(new EETypePtr(context)), *(RuntimeMethodHandle *)&signature); break; case SignatureKind.OpenInstanceResolver: result = Internal.Runtime.CompilerServices.OpenMethodResolver.ResolveMethodWorker(signature, contextObject); break; case SignatureKind.DefaultConstructor: { result = RuntimeAugments.TypeLoaderCallbacks.TryGetDefaultConstructorForType(new RuntimeTypeHandle(new EETypePtr(context))); if (result == IntPtr.Zero) { result = RuntimeAugments.GetFallbackDefaultConstructor(); } } break; case SignatureKind.GenericDelegateThunk: result = RuntimeAugments.TypeLoaderCallbacks.GetDelegateThunk((Delegate)contextObject, (int)signature); break; default: result = RawCalliHelper.Call <IntPtr>(s_resolutionFunctionPointers[(int)signatureKind], context, signature, contextObject, out auxResult); break; } } // // Update the cache under the lock // if (s_lock == null) { Interlocked.CompareExchange(ref s_lock, new Lock(), null); } s_lock.Acquire(); try { // Avoid duplicate entries Entry existingEntry = LookupInCache(s_cache, context, signature); if (existingEntry != null) { return(existingEntry); } // Resize cache as necessary Entry[] cache = ResizeCacheForNewEntryAsNecessary(); int key = ((context.GetHashCode() >> 4) ^ signature.GetHashCode()) & (cache.Length - 1); Entry newEntry = new Entry() { Context = context, Signature = signature, Result = result, AuxResult = auxResult, Next = cache[key] }; cache[key] = newEntry; return(newEntry); } finally { s_lock.Release(); } }
// TOOD: add ctor to SignatureHeader internal static SignatureHeader SignatureHeader(SignatureKind kind, SignatureCallingConvention convention, SignatureAttributes attributes) { return new SignatureHeader((byte)((int)kind | (int)convention | (int)attributes)); }
internal static IEnumerable <ICmsSignature> VisitAll(this ICmsSignature signature, SignatureKind kind, bool deep) { foreach (var nested in signature.GetNestedSignatures()) { if ((nested.Kind & kind) > 0) { yield return(nested); foreach (var nestVisit in nested.VisitAll(kind, deep)) { yield return(nestVisit); } } else if (deep) { foreach (var nestVisit in nested.VisitAll(kind, deep)) { yield return(nestVisit); } } } }
internal static IEnumerable <ICmsSignature> VisitAll(this IReadOnlyList <ICmsSignature> signatures, SignatureKind kind, bool deep) { foreach (var signature in signatures) { if ((signature.Kind & kind) > 0) { yield return(signature); } foreach (var nested in VisitAll(signature, kind, deep)) { yield return(nested); } } }
internal Signature(SignatureKind kind, CryptMsgSafeHandle messageHandle, LocalBufferSafeHandle signerHandle) { Kind = kind; InitFromHandles(messageHandle, signerHandle); }
public SignatureHeader(SignatureKind kind, SignatureCallingConvention convention, SignatureAttributes attributes) : this((byte)((int)kind | (int)convention | (int)attributes)) { }
/// <summary> /// To signed some type of data /// </summary> /// <param name="data">String with the data you want to sign</param> /// <param name="callback"></param> /// <param name="platform"></param> /// <param name="signature"></param> public void SignData(string data, Action <bool, string, string, string> callback = null, PlatformKind platform = PlatformKind.Phantasma, SignatureKind signature = SignatureKind.Ed25519) { if (!Enabled) { callback(true, "not logged in", "", ""); return; } if (data == null) { callback(true, "invalid data, sorry :(", "", ""); return; } if (data.Length >= 1024) { callback(true, "data too big, sorry :(", "", ""); return; } var dataConverted = Base16.Encode(Encoding.UTF8.GetBytes(data)); SendLinkRequest($"signData/{dataConverted}/{signature}/{platform}", (result) => { var success = result.GetBool("success"); if (success) { var random = result.GetString("random"); var signedData = result.GetString("signature"); callback?.Invoke(false, signedData, random, dataConverted); } else { var msg = result.GetString("message"); callback?.Invoke(true, "transaction rejected: " + msg, "", ""); } }); }
/// <summary> /// Send Transaction. /// </summary> /// <param name="chain"></param> /// <param name="script"></param> /// <param name="payload"></param> /// <param name="callback"></param> public void SendTransaction(string chain, byte[] script, byte[] payload, Action <Hash, string> callback = null, PlatformKind platform = PlatformKind.Phantasma, SignatureKind signature = SignatureKind.Ed25519) { SetMessage("Relaying transaction..."); if (script.Length >= 8192) { callback(Hash.Null, "script too big"); return; } var hexScript = Base16.Encode(script); var hexPayload = payload != null && payload.Length > 0 ? Base16.Encode(payload) : ""; // is empty string for payload ok? var requestStr = $"{chain}/{hexScript}/{hexPayload}"; if (Version >= 2) { requestStr = $"{requestStr}/{signature}/{platform}"; } else { requestStr = $"{this.Nexus}/{requestStr}"; } SendLinkRequest($"signTx/{requestStr}", (result) => { var success = result.GetBool("success"); if (success) { var hashStr = result.GetString("hash"); var hash = Hash.Parse(hashStr); callback?.Invoke(hash, null); } else { var msg = result.GetString("message"); callback?.Invoke(Hash.Null, "transaction rejected: " + msg); } }); }
protected override void SignTransaction(string platform, SignatureKind kind, string chain, byte[] script, byte[] payload, int id, Action <Hash, string> callback) { var accountManager = AccountManager.Instance; var targetPlatform = RequestPlatform(platform); if (targetPlatform == PlatformKind.None) { callback(Hash.Null, "Unsupported platform: " + platform); return; } var state = AccountManager.Instance.CurrentState; if (state == null) { callback(Hash.Null, "not logged in"); return; } var nexus = AccountManager.Instance.Settings.nexusName; var account = AccountManager.Instance.CurrentAccount; WalletGUI.Instance.CallOnUIThread(() => { try { WalletGUI.Instance.StartCoroutine(DescriptionUtils.GetDescription(script, (description, error) => { if (description == null) { WalletGUI.Instance.MessageBox(MessageKind.Error, "Error during description parsing.\nContact the developers.\nDetails: " + error); callback(Hash.Null, "description parsing error"); return; } WalletGUI.Instance.Prompt("Allow dapp to send a transaction on your behalf?\n" + description, (success) => { if (success) { WalletGUI.Instance.SendTransaction(description, script, payload, chain, ProofOfWork.None, (hash) => { AppFocus.Instance.EndFocus(); if (hash != Hash.Null) { callback(hash, null); } else { callback(Hash.Null, "something bad happend while sending"); } }); } else { AppFocus.Instance.EndFocus(); callback(Hash.Null, "user rejected"); } }); })); } catch (Exception e) { WalletGUI.Instance.MessageBox(MessageKind.Error, "Error during description parsing.\nContact the developers.\nDetails: " + e.Message); callback(Hash.Null, "description parsing error"); return; } }); }
public static IEnumerable <ISignature> VisitAll(this IReadOnlyList <ISignature> signatures, SignatureKind kind) { foreach (var signature in signatures) { if ((signature.Kind & kind) > 0) { yield return(signature); } foreach (var nested in VisitAll(signature, kind)) { yield return(nested); } } }
protected override void SignData(string platform, SignatureKind kind, byte[] data, int id, Action <string, string, string> callback) { var accountManager = AccountManager.Instance; var targetPlatform = RequestPlatform(platform); if (targetPlatform == PlatformKind.None) { callback(null, null, "Unsupported platform: " + platform); return; } var state = AccountManager.Instance.CurrentState; if (state == null) { callback(null, null, "not logged in"); return; } if (kind != SignatureKind.Ed25519) { callback(null, null, kind + " signatures unsupported"); return; } var account = AccountManager.Instance.CurrentAccount; WalletGUI.Instance.CallOnUIThread(() => { var description = System.Text.Encoding.UTF8.GetString(data); WalletGUI.Instance.Prompt("The dapp wants to sign the following data. Accept?\n" + description, (success) => { AppFocus.Instance.EndFocus(); if (success) { var phantasmaKeys = PhantasmaKeys.FromWIF(account.GetWif(AccountManager.Instance.CurrentPasswordHash)); var randomValue = UnityEngine.Random.Range(0, int.MaxValue); var randomBytes = BitConverter.GetBytes(randomValue); var msg = ByteArrayUtils.ConcatBytes(randomBytes, data); var signature = phantasmaKeys.Sign(msg); byte[] sigBytes = null; using (var stream = new MemoryStream()) { using (var writer = new BinaryWriter(stream)) { writer.WriteSignature(signature); } sigBytes = stream.ToArray(); } var hexSig = Base16.Encode(sigBytes); var hexRand = Base16.Encode(randomBytes); callback(hexSig, hexRand, null); } else { callback(null, null, "user rejected"); } }); }); }
void ISymbolDisplayBuilder.BuildSignatureDisplay(ISignature signatures, ISymbolWriter writer, INode enclosingDeclaration, TypeFormatFlags flags, SignatureKind kind) { BuildSignatureDisplay(signatures, writer, enclosingDeclaration, flags, kind, symbolStack: null); }
// NOTE for security, signData should not be usable as a way of signing transaction. That way the wallet is responsible for appending random bytes to the message, and return those in callback protected abstract void SignData(byte[] data, SignatureKind kind, int id, Action <string, string, string> callback);
/// <summary> /// Sets a new function signature kind. /// </summary> /// <param name="kind">The new signature kind.</param> /// <returns>The builder, with the change applied.</returns> public FunctionSignatureBuilder WithKind(SignatureKind kind) { _newKind = kind; return(this); }
// TOOD: add ctor to SignatureHeader internal static SignatureHeader SignatureHeader(SignatureKind kind, SignatureCallingConvention convention, SignatureAttributes attributes) { return(new SignatureHeader((byte)((int)kind | (int)convention | (int)attributes))); }
protected abstract void SignTransaction(string platform, SignatureKind kind, string chain, byte[] script, byte[] payload, int id, Action <Hash, string> callback);