Objectif Équivaut à base16(). Decode (Chaîne)

Question

Actuellement, notre équipe travaille sur une clé HMAC mais les résultats sur iOS et Android sont différents. La partie Java fonctionne correctement, mais la partie iOS semble ne pas fonctionner.

Nous avons établi que le problème est avec le HMAC_KEY dans java la première clé est convertie en un octet de base16 []. Quel serait l'équivalent Objective-C de ce qui suit?

 byte[] hmacKey = BaseEncoding.base16().decode(HMAC_KEY); 
     SecretKeySpec signingKey = new SecretKeySpec(hmacKey, HMAC_SHA256_ALGORITHM); 
     Mac mac = Mac.getInstance(HMAC_SHA256_ALGORITHM); 
     mac.init(signingKey); 
     byte[] rawHmac = mac.doFinal(data.getBytes(C_UTF8)); 



     return BaseEncoding.base64().encode(rawHmac); 

curently dans ios nous avons les éléments suivants:

NSData *saltData = [salt dataUsingEncoding:NSUTF8StringEncoding]; 
NSData *paramData = [signingData dataUsingEncoding:NSUTF8StringEncoding]; 
NSMutableData* hash = [NSMutableData dataWithLength:CC_SHA256_DIGEST_LENGTH ]; 
CCHmac(kCCHmacAlgSHA256, saltData.bytes, saltData.length, paramData.bytes, paramData.length, hash.mutableBytes); 
NSString *base64Hash = [hash base64Encoding]; 

le problème est la BaseEncoding.base16().decode(HMAC_KEY) partie Withing comment pouvons-nous faire cela à l'Objective-C?

Answer 1

À partir de votre code Java, vous devez d'abord convertir HMAC_KEY (HexDecimalString) en NSData, puis vous pouvez effectuer le calcul HMAC_SHA256. Ceci est ma solution Swift

public extension String { 

    func sha256(key: NSData) -> String { 
     let inputData: NSData = self.dataUsingEncoding(NSUTF8StringEncoding, allowLossyConversion: false)! 
     let keyData = UnsafePointer<UInt8>(key.bytes) 

     let algorithm = HMACAlgorithm.SHA256 
     let digestLen = algorithm.digestLength() 
     let result = UnsafeMutablePointer<CUnsignedChar>.alloc(digestLen) 

     CCHmac(algorithm.toCCHmacAlgorithm(), keyData, key.length, inputData.bytes, Int(inputData.length), result) 
     let data = NSData(bytes: result, length: digestLen) 
     result.destroy() 
     return data.base64EncodedStringWithOptions(NSDataBase64EncodingOptions.Encoding64CharacterLineLength) 
    } 

    func dataFromHexadecimalString() -> NSData? { 
     let data = NSMutableData(capacity: characters.count/2) 

     let regex = try! NSRegularExpression(pattern: "[0-9a-f]{1,2}", options: .CaseInsensitive) 
     regex.enumerateMatchesInString(self, options: [], range: NSMakeRange(0, characters.count)) { match, flags, stop in 
      let byteString = (self as NSString).substringWithRange(match!.range) 
      var num = UInt8(byteString, radix: 16) 
      data?.appendBytes(&num, length: 1) 
     } 

     return data 
    } 
} 

enum HMACAlgorithm { 
    case MD5, SHA1, SHA224, SHA256, SHA384, SHA512 

    func toCCHmacAlgorithm() -> CCHmacAlgorithm { 
     var result: Int = 0 
     switch self { 
     case .MD5: 
      result = kCCHmacAlgMD5 
     case .SHA1: 
      result = kCCHmacAlgSHA1 
     case .SHA224: 
      result = kCCHmacAlgSHA224 
     case .SHA256: 
      result = kCCHmacAlgSHA256 
     case .SHA384: 
      result = kCCHmacAlgSHA384 
     case .SHA512: 
      result = kCCHmacAlgSHA512 
     } 
     return CCHmacAlgorithm(result) 
    } 

    func digestLength() -> Int { 
     var result: CInt = 0 
     switch self { 
     case .MD5: 
      result = CC_MD5_DIGEST_LENGTH 
     case .SHA1: 
      result = CC_SHA1_DIGEST_LENGTH 
     case .SHA224: 
      result = CC_SHA224_DIGEST_LENGTH 
     case .SHA256: 
      result = CC_SHA256_DIGEST_LENGTH 
     case .SHA384: 
      result = CC_SHA384_DIGEST_LENGTH 
     case .SHA512: 
      result = CC_SHA512_DIGEST_LENGTH 
     } 
     return Int(result) 
    } 
} 

Vous pouvez simplement obtenir base64Hash comme ça et le résultat a été vérifié:

print(dataString.sha256(HMAC_KEY.dataFromHexadecimalString()))