logo标签列表

C#中与Java SecretKeySpec相当的是什么？

javac#cryptographysha1hmac
12

我有以下Java代码：

Mac mac = Mac.getInstance("HmacSHA1");
String secretKey ="sKey";
String content ="Hello";

byte[] secretKeyBArr = secretKey.getBytes();    
byte[] contentBArr = content.getBytes();

SecretKeySpec secret_key = new SecretKeySpec(secretKeyBArr,"HmacSHA1");
byte[] secretKeySpecArr = secret_key.getEncoded();

mac.init(secret_key);

byte[] final = mac.doFinal(contentBArr);

我希望能够在C#中制作一个类似的示例，因此我编写了以下代码

HMACSHA1 hmacsha1 = new HMACSHA1();
string secretKey = "sKey";
string content = "Hello";

byte[] secretKeyBArr = Encoding.UTF8.GetBytes(secretKey);
byte[] contentBArr = Encoding.UTF8.GetBytes(content);

hmacsha1.Key = secretKeyBArr;
byte[] final = hmacsha1.ComputeHash(contentBArr);

最终结果不相等。secretKeyBArr和contentBArr是字节数组，在两个示例中其值相同。未知的是传递给mac.init()的SecretKeySpec。那么，在C＃中有什么等效的同一类？

2
你可能想编辑问题的标题以反映关于C#中与Java SecretKeySpec相当的内容。 - Keith Nicholas
SecretKeySpec 除了在 "HmacSha1" 的情况下存储字节之外，似乎并没有做太多事情。问题很可能出在其他地方。 - Maarten Bodewes
PS你如何比较结果？ - Maarten Bodewes
准确地说，只需单独读取字节即可。 - user1810618
是的，我可以使用final作为标识符。我现在只是处于调试模式。但是，好的，我会将其重命名 :) - user1810618
显示剩余5条评论
2个回答
1

我正在实现一个从不提供 .net 实现的提供商（Cardinity）的信用卡支付方法。我正在寻找类似的内容，最终因为我的谷歌搜索技能似乎有限而编写了自己的实现。

我需要 javax.crypto.mac 的 base64 字符串。

我支持以下方法：

enum EncryptionMethods
{
    None=0,
    HMACSHA1,
    HMACSHA256,
    HMACSHA384,
    HMACSHA512,
    HMACMD5
}

我已经按照你上面提供的代码实现了SecretKeySpec和Mac（需要System.Security.Cryptography.ProtectedData）：

internal class Protected
{
    private  Byte[] salt = Guid.NewGuid().ToByteArray();

    protected byte[] Protect(byte[] data)
    {
        try
        {
            return ProtectedData.Protect(data, salt, DataProtectionScope.CurrentUser);
        }
        catch (CryptographicException)//no reason for hackers to know it failed
        {
            return null;
        }
    }

    protected byte[] Unprotect(byte[] data)
    {
        try
        {
            return ProtectedData.Unprotect(data, salt, DataProtectionScope.CurrentUser);
        }
        catch (CryptographicException)//no reason for hackers to know it failed
        {
            return null;
        }
    }
}


internal class SecretKeySpec:Protected,IDisposable
{
    readonly EncryptionMethods _method;

    private byte[] _secretKey;
    public SecretKeySpec(byte[] secretKey, EncryptionMethods encryptionMethod)
    {
        _secretKey = Protect(secretKey);
        _method = encryptionMethod;
    }

    public EncryptionMethods Method => _method;
    public byte[] SecretKey => Unprotect( _secretKey);

    public void Dispose()
    {
        if (_secretKey == null)
            return;
        //overwrite array memory
        for (int i = 0; i < _secretKey.Length; i++)
        {
            _secretKey[i] = 0;
        }

        //set-null
        _secretKey = null;
    }
    ~SecretKeySpec()
    {
        Dispose();
    }
}

internal class Mac : Protected,IDisposable
{
    byte[] rawHmac;
    HMAC mac;
    public Mac(SecretKeySpec key, string data)
    {

        switch (key.Method)
        {
            case EncryptionMethods.HMACMD5:
                mac = new HMACMD5(key.SecretKey);
                break;
            case EncryptionMethods.HMACSHA512:
                mac = new HMACSHA512(key.SecretKey);
                break;
            case EncryptionMethods.HMACSHA384:
                mac = new HMACSHA384(key.SecretKey);
                break;
            case EncryptionMethods.HMACSHA256:
                mac = new HMACSHA256(key.SecretKey);

            break;
            case EncryptionMethods.HMACSHA1:
                mac = new HMACSHA1(key.SecretKey);
                break;

            default:                    
                throw new NotSupportedException("not supported HMAC");
        }
        rawHmac = Protect( mac.ComputeHash(Cardinity.ENCODING.GetBytes(data)));            

    }

    public string AsBase64()
    {
        return System.Convert.ToBase64String(Unprotect(rawHmac));
    }

    public void Dispose()
    {
        if (rawHmac != null)
        {
            //overwrite memory address
            for (int i = 0; i < rawHmac.Length; i++)
            {
                rawHmac[i] = 0;
            }

            //release memory now
            rawHmac = null;

        }
        mac?.Dispose();
        mac = null;

    }
    ~Mac()
    {
        Dispose();
    }
}

我已经在OAuthSigner类中以以下方式实现了这个功能：
public override string ComputeSignature(string plainTextToEncode, string consumerSecret)
{
    var key = PercentEncode(consumerSecret) + "&";
    try
    {
        using (var secretKey = new SecretKeySpec(key.GetBytes(), EncryptionMethods.HMACSHA1))
        using (Mac mac = new Mac(secretKey, plainTextToEncode))
        {
            return mac.AsBase64();
        }
    }
    finally
    {
        key = null;//free memory, remove sensitive data
    }
}

那么，这不是你要求的东西，但我需要一个帮助方法，因为我正在将我的文本发送到一个类似于以下内容的 web 服务，并将其包含在其中，因为有些人可能会复制代码：

public static String PercentEncode(string textToEncode)
{

    return string.IsNullOrEmpty(textToEncode)
        ?""
        : UrlEncoder.Default.Encode(Cardinity.ENCODING.GetString(Cardinity.ENCODING.GetBytes(textToEncode)))
            .Replace("+", "%20").Replace("*", "%2A")
            .Replace("%7E", "~");

}

UrlEncoder类来自System.Text.Encodings.Web，您可能需要添加引用。

名为Cardinity的类实现了我用于Cardinity的编码的“快捷方式”

public abstract class Cardinity
{
    ...
    public static String API_BASE = "https://api.cardinity.com";
    public static String API_VERSION = "v1";
    public static String VERSION = "0.1";
    public static String ENCODING_CHARSET = "UTF-8";
    public static Encoding ENCODING => Encoding.UTF8;
}

由于Java经常使用string.GetBytes，因此我添加了一个扩展方法，在key.GetBytes()中调用它，以下是扩展代码：

public static byte[] GetBytes(this string sender)=>
            Cardinity.ENCODING.GetBytes(sender);

我的测试方法，我已经复制了从 Cardinity API 传递的值，没有任何问题。

private OAuthSigner signer;
public HmacOAuthSigner_Test()
{
    signer = new HmacOAuthSigner();
}

[TestMethod]
public void Test_HmacOAuthSigner_ComputeSignature_DefaultText()
{
    var expects = "PxkffxyQh6jsDNcgJ23GpAxs2y8=";
    var test_data = "justsomerandommessage";
    var secretkey = "yvp0leodf231ihv9u29uuq6w8o4cat9qz2nkvs55oeu833s621";

    var actual = signer.ComputeSignature(test_data, secretkey);
    Assert.AreEqual(expects, actual, $"Expecting {test_data} to return {expects} received {actual}");
}

整个 HmacOAuthSigner 的实现在这里，它实现了一个抽象类，并在其中包含 PercentEncode 方法。
public class HmacOAuthSigner : OAuthSigner
{
    public override string ComputeSignature(string signatureBaseString, string consumerSecret)
    {
        var key = PercentEncode(consumerSecret) + "&";
        var secretKey = new SecretKeySpec(key.GetBytes(), EncryptionMethods.HMACSHA1);
        using (Mac mac = new Mac(secretKey, signatureBaseString))
        {
            return mac.AsBase64();
        }
    }

    public override string GetSignatureMethod()
    {
        return "HMAC-SHA1";
    }
}

以及我用作所有实现约定的抽象类：

public abstract class OAuthSigner
{
    /// <summary>
    /// Signature method used
    /// </summary>
    /// <returns>a string that tells the implementation method</returns>
    public abstract string GetSignatureMethod();

    /// <summary>
    /// computes the signature that is used with the encryption based on the keys provided by cardinity
    /// </summary>
    /// <param name="signatureBaseString">The secret string that services as a base</param>
    /// <param name="consumerSecret">The consumer key as specified in the API settings</param>
    /// <returns>signature string computed by the provided parameters using the signature method</returns>
    public abstract string ComputeSignature(String signatureBaseString, String consumerSecret);

    /// <summary>
    /// Encode a string into a format expected by Cardinity
    /// </summary>
    /// <param name="textToEncode">The text that is to be encoded</param>
    /// <returns>web encoded string ready for using to send to Cardinity</returns>
    public static String PercentEncode(string textToEncode)
    {

        return string.IsNullOrEmpty(textToEncode)
            ?""
            : UrlEncoder.Default.Encode(Cardinity.ENCODING.GetString(Cardinity.ENCODING.GetBytes(textToEncode)))
                .Replace("+", "%20").Replace("*", "%2A")
                .Replace("%7E", "~");

    }
}
它的工作方式与Java相同。 - LastCyborg
1

结果是相同的，但Java默认使用有符号字节，而C#默认使用无符号字节。

此外，SecretKeySpec 本身通常不会更改底层数据。您需要将DES密钥规范放入 SecretKeyFactory 中，以确保奇偶校验位被正确设置（在生成的 SecretKey 中）。因此，除了包装数据之外，该类本身几乎没有任何作用，因此不需要等效的类。

好的，但是Java代码现在使用默认字符编码。如果返回的编码与UTF-8不同（对于ASCII文本来说不太可能，但对于其他文本来说非常可能），那么比较将失败。 - Maarten Bodewes
刚刚我尝试了一下。使用getBytes(Charset.forName("UTF-8"))方法，我得到了和之前相同的值。 - user1810618
结果中没有 '[' 字符，希望是这样的吗？ - Maarten Bodewes
我在VS和Eclipse中比较最终的字节数组。 - user1810618
1
这是正确的。将C#中的字节数组转换为有符号字节数组已解决问题。 - user1810618
网页内容由stack overflow 提供, 点击上面的
可以查看英文原文，
原文链接