anchor.diff:  					HostPubBin, Prime);
   		    [S] -> S
   		end,
  -    srp_user_secret_nif(UserPrivate, Scrambler, HostPubBin, Multiplier,
  -			  Generator, DerivedKey, Prime);
  +    srp_user_secret_nif(ensure_int_as_bin(UserPrivate), Scrambler, HostPubBin,
  +			Multiplier, Generator, DerivedKey, Prime);
   
   compute_key(srp, UserPublic, {HostPublic, HostPrivate},
   	    {host,[Verifier, Prime, Version | ScramblerArg]}) when
         is_binary(Verifier),
         is_binary(Prime),
  -      is_binary(HostPrivate),
         is_atom(Version) ->
       UserPubBin = ensure_int_as_bin(UserPublic),
       Scrambler = case ScramblerArg of
   		    [] -> srp_scrambler(Version, UserPubBin, ensure_int_as_bin(HostPublic), Prime);
   		    [S] -> S
   		end,
  -    srp_host_secret_nif(Verifier, HostPrivate, Scrambler, UserPubBin, Prime);
  +    srp_host_secret_nif(Verifier, ensure_int_as_bin(HostPrivate), Scrambler,
  +			UserPubBin, Prime);
   
   compute_key(ecdh, Others, My, Curve) ->
       ecdh_compute_key_nif(ensure_int_as_bin(Others),
  
positive.code:   when is_binary(Verifier), is_binary(Generator), is_binary(Prime), is_atom(Version) ->
      Private = case PrivArg of
  		  undefined -> random_bytes(32);
  		  _ -> PrivArg
  	      end,
      host_srp_gen_key(Private, Verifier, Generator, Prime, Version);
  
  
negative.code: 	    {user, [DerivedKey, Prime, Generator, Version | ScramblerArg]}) when
        is_binary(Prime),
        is_binary(Generator),
        is_atom(Version) ->
      HostPubBin = ensure_int_as_bin(HostPublic),
      Multiplier = srp_multiplier(Version, Generator, Prime),
  