protected void btnGenerateSecret_Click(object sender, EventArgs e)
{
var hmac = new HMACSHA256();
var key = Base32Encoding.ToString(hmac.Key);
txtGeneratedSecret.Text = key;
}
private Totp GetTotp(string secret)
{
var key = Base32Encoding.ToBytes(secret);
var totp = new Totp(key);
return(totp);
}
public static object GetKey2FA(string key)
{
object result;
try
{
object obj;
try
{
byte[] array = Base32Encoding.ToBytes(key.Trim().Replace(" ", ""));
Totp totp = new Totp(array, 30, 0, 6, null);
obj = totp.ComputeTotp(DateTime.UtcNow);
goto IL_44;
}
catch (Exception)
{
}
obj = null;
IL_44:
result = obj;
}
catch (Exception exception)
{
return("");
}
return(result);
}
static async Task Main()
{
string username = Environment.GetEnvironmentVariable("TESLA_USERNAME") ?? await RL("Username");
string password = Environment.GetEnvironmentVariable("TESLA_PW") ?? await RL("Password");
string mfaCode = (mfaCode = Environment.GetEnvironmentVariable("TESLA_KEY")) != null
? new Totp(Base32Encoding.ToBytes(mfaCode)).ComputeTotp()
: await RL("MFA");
var region = TeslaAccountRegion.Unknown;
ServicePointManager.FindServicePoint(new Uri("https://auth.tesla.com")).ConnectionLeaseTimeout = 60 * 1000;
ServicePointManager.FindServicePoint(new Uri("https://auth.tesla.com")).ConnectionLimit = 10;
ServicePointManager.FindServicePoint(new Uri("https://owner-api.teslamotors.com")).ConnectionLeaseTimeout = 60 * 1000;
ServicePointManager.FindServicePoint(new Uri("https://owner-api.teslamotors.com")).ConnectionLimit = 10;
var authHelper = new TeslaAuthHelper("TeslaAuthHelperTest/1.0", region);
using var cts = new CancellationTokenSource(TimeSpan.FromSeconds(15));
var tokens = await authHelper.AuthenticateAsync(username, password, mfaCode, cts.Token);
System.Console.WriteLine("Access token: " + tokens.AccessToken);
System.Console.WriteLine("Refresh token: " + tokens.RefreshToken);
System.Console.WriteLine("Created at: " + tokens.CreatedAt);
System.Console.WriteLine("Expires in: " + tokens.ExpiresIn);
var newToken = await authHelper.RefreshTokenAsync(tokens.RefreshToken, cts.Token);
System.Console.WriteLine("Refreshed Access token: " + newToken.AccessToken);
System.Console.WriteLine("New Refresh token: " + newToken.RefreshToken);
System.Console.WriteLine("Refreshed token created at: " + newToken.CreatedAt);
System.Console.WriteLine("Refreshed token expires in: " + newToken.ExpiresIn);
}
public void GetUriSuccess(HashAlgorithmType hashAlgorithm, byte period, byte digits)
{
var id = Guid.NewGuid().ToString();
var secret = new byte[32];
using (var rng = RandomNumberGenerator.Create())
{
rng.GetBytes(secret);
}
var options = GetOptions();
options.Value.HashAlgorithm = hashAlgorithm;
options.Value.NumberOfDigits = digits;
options.Value.PeriodInSeconds = period;
var service = new AuthenticatorService(options, new DefaultSystemTime());
var uri = service.GetUri(id, secret);
Assert.Equal(string.Format("otpauth://totp/{0}%3A{1}?secret={2}&issuer={0}&algorithm={3}&digits={4}&period={5}",
Issuer,
id,
Base32Encoding.Encode(secret).Trim('='),
hashAlgorithm.ToString(),
digits,
period
), uri);
}
public static string DecryptString(string EncryptedText, Type baseOption)
{
byte[] encryptedTextBytes;
if (baseOption == typeof(Int64))
{
encryptedTextBytes = Convert.FromBase64String(EncryptedText);
}
else
{
encryptedTextBytes = Base32Encoding.ToBytes(EncryptedText);
}
MemoryStream ms = new MemoryStream();
System.Security.Cryptography.SymmetricAlgorithm rijn = SymmetricAlgorithm.Create();
byte[] rgbIV = Encoding.ASCII.GetBytes("lbavittzoaofgcqz");
byte[] key = Encoding.ASCII.GetBytes("rymnwalaspjdbygwagsxhzzcroywhciu");
CryptoStream cs = new CryptoStream(ms, rijn.CreateDecryptor(key, rgbIV),
CryptoStreamMode.Write);
cs.Write(encryptedTextBytes, 0, encryptedTextBytes.Length);
cs.Close();
return(Encoding.UTF8.GetString(ms.ToArray()));
}
public static bool IsValidSecret(string secret, AuthenticatorType type)
{
if (String.IsNullOrEmpty(secret))
{
return(false);
}
if (type.IsHmacBased())
{
try
{
return(Base32Encoding.ToBytes(secret).Length > 0);
}
catch (ArgumentException)
{
return(false);
}
}
if (type == AuthenticatorType.MobileOtp)
{
return(secret.Length >= MobileOtp.SecretMinLength);
}
throw new ArgumentOutOfRangeException(nameof(type));
}
public async Task GetTwoFactorAsync(User user, TwoFactorProviderType provider)
{
if (user.TwoFactorEnabled && user.TwoFactorProvider.HasValue && user.TwoFactorProvider.Value == provider)
{
switch (provider)
{
case TwoFactorProviderType.Authenticator:
if (!string.IsNullOrWhiteSpace(user.AuthenticatorKey))
{
return;
}
break;
default:
throw new ArgumentException(nameof(provider));
}
}
user.TwoFactorProvider = provider;
// Reset authenticator key.
user.AuthenticatorKey = null;
switch (provider)
{
case TwoFactorProviderType.Authenticator:
var key = KeyGeneration.GenerateRandomKey(20);
user.AuthenticatorKey = Base32Encoding.ToString(key);
break;
default:
throw new ArgumentException(nameof(provider));
}
await SaveUserAsync(user);
}
private async void Done_Click(object sender, RoutedEventArgs e)
{
var resourceLoader = Windows.ApplicationModel.Resources.ResourceLoader.GetForCurrentView();
if (otp_secret.Text == "")
{
err_text.Text = resourceLoader.GetString("err_empty_secret");
}
else
{
try
{
Base32Encoding.ToBytes(otp_secret.Text.Trim());
otp.Issuer = otp_issuer.Text;
otp.Name = otp_label.Text;
otp.Secret = otp_secret.Text;
otp.Type = otp_type.SelectedIndex;
otp.Algorithm = otp_algorithm.SelectedIndex;
otp.Digits = (int)otp_digits.SelectedItem;
otp.Period = (int)otp_period.SelectedItem;
otp.LogoType = type;
otp.Logo = logo;
await SqlAccess.Update_Item(otp);
MainPage.mainPage.init_data();
back();
}
catch
{
err_text.Text = resourceLoader.GetString("err_wrong_secret");
}
}
}
public string GenerateTotpCode(User user)
{
var totpSecretKey = Base32Encoding.ToBytes(user.TotpSecretKey);
var totp = new Totp(totpSecretKey);
return(totp.ComputeTotp());
}
public async Task <IActionResult> VerifyTOTPCode(TOTPRequest request)
{
User user = _dbContext.Users.SingleOrDefault(u => u.Id == request.RequestorId);
if (user is null)
{
return(NotFound("User does not exist."));
}
byte[] totpSecret = Base32Encoding.ToBytes(user.TOTPSecret);
Totp totp = new Totp(totpSecret);
VerificationWindow window = new VerificationWindow(previous: 1, future: 1);
bool isValid = totp.VerifyTotp(request.Code, out var _, window);
if (isValid)
{
MFAToken token = await MFAToken.GenerateAsync(user.AccountId, user.TOTPSecret);
return(Ok(token));
}
else
{
return(BadRequest("Code is invalid."));
}
}
private async void Done_Click(object sender, RoutedEventArgs e)
{
var resourceLoader = Windows.ApplicationModel.Resources.ResourceLoader.GetForCurrentView();
if (otp_secret.Text == "")
{
err_text.Text = resourceLoader.GetString("err_empty_secret");
scroll1.ChangeView(0, 0, 1);
}
else
{
try
{
Base32Encoding.ToBytes(otp_secret.Text.Trim());
await SqlAccess.Add_Item(0, otp_issuer.Text, otp_label.Text, otp_secret.Text, otp_algorithm.SelectedIndex, (int)otp_digits.SelectedValue, (int)otp_period.SelectedValue, type, logo);
MainPage.mainPage.init_data();
back();
}
catch
{
err_text.Text = resourceLoader.GetString("err_wrong_secret");
scroll1.ChangeView(0, 0, 1);
}
}
}
public string GetPlainSecret()
{
if (this.Key.ReadData().Length > 0)
{
if (this.Encoding == OtpSecretEncoding.Base32)
{
return(Base32Encoding.ToString(this.Key.ReadData()));
}
else if (this.Encoding == OtpSecretEncoding.Base64)
{
return(Convert.ToBase64String(this.Key.ReadData()));
}
else if (this.Encoding == OtpSecretEncoding.Hex)
{
return(MemUtil.ByteArrayToHexString(this.Key.ReadData()));
}
else if (this.Encoding == OtpSecretEncoding.UTF8)
{
return(StrUtil.Utf8.GetString(this.Key.ReadData()));
}
else
{
return(null);
}
}
return(null);
}
public void TimeBasedTokenizationWorks(DateTime time, string expectedOTP)
{
Target.Secret = Base32Encoding.ToBytes("AAAAAAAAAAAA");
var otp = Target.GenerateOTP(time);
Assert.Equal(expectedOTP, otp);
}
public void VerifyKeys(string secret, ulong counter, string code)
{
var authenticator = new CounterAuthenticator();
var base32Secret = Base32Encoding.ToString(Encoding.ASCII.GetBytes(secret));
Assert.IsTrue(authenticator.CheckCode(base32Secret, code, counter));
}
private void FromFilename(string name, out long startTime, out int fileSize)
{
var segments = name.Split('-');
startTime = BitConverter.ToInt64(Base32Encoding.ToBytes(segments[0]), 0);
fileSize = BitConverter.ToInt32(Base32Encoding.ToBytes(segments[1]), 0);
}
static int Main(string[] args)
{
if (!CommandLineSwitch.TryParse <Options>(ref args, out var options, out var err))
{
Console.WriteLine($"ERROR: {err}");
return(-1);
}
if (string.IsNullOrEmpty(options.Key))
{
Console.WriteLine("ERROR: Secret Key is not specified.");
ShowUsage();
return(-1);
}
var secretKey = default(byte[]);
try { secretKey = Base32Encoding.ToBytes(options.Key); }
catch (ArgumentException)
{
Console.WriteLine("ERROR: Invalid key format.");
return(-1);
}
var totp = new Totp(secretKey);
var totpCode = totp.ComputeTotp();
Console.WriteLine(totpCode);
return(0);
}
public async Task IncrementHotp(int position)
{
if (Authenticators.ElementAtOrDefault(position) == null)
{
return;
}
var info = Authenticators[position];
var auth = GetAuthenticator(info);
if (auth.Type != AuthenticatorType.Hotp)
{
return;
}
var secret = Base32Encoding.ToBytes(auth.Secret);
var hotp = new Hotp(secret, auth.Algorithm);
auth.Counter++;
auth.Code = hotp.ComputeHOTP(auth.Counter);
auth.TimeRenew = DateTime.Now.AddSeconds(10);
Authenticators[position] = auth;
await _connection.UpdateAsync(auth);
}
[Test] public void Base32()
{
{
var data = new byte[] { 0xff };
var enc = Base32Encoding.ToString(data);
var dec = Base32Encoding.ToBytes(enc);
Assert.Equal(enc.Length, Base32Encoding.EncodedLength(data.Length));
Assert.Equal(dec.Length, Base32Encoding.DecodedLength(enc));
Assert.Equal(0, Array_.Compare(data, 0, data.Length, dec, 0, dec.Length));
}
{
var data = new byte[256];
for (int i = 0; i != data.Length; ++i)
{
data[i] = (byte)i;
}
var enc = Base32Encoding.ToString(data);
var dec = Base32Encoding.ToBytes(enc);
Assert.Equal(enc.Length, Base32Encoding.EncodedLength(data.Length));
Assert.Equal(dec.Length, Base32Encoding.DecodedLength(enc));
Assert.Equal(0, Array_.Compare(data, 0, data.Length, dec, 0, dec.Length));
}
var rand = new Random(42);
for (int i = 0; i != 100; ++i)
{
var data = new byte[rand.Next(16000)];
rand.NextBytes(data);
var enc = Base32Encoding.ToString(data);
var dec = Base32Encoding.ToBytes(enc);
Assert.Equal(enc.Length, Base32Encoding.EncodedLength(data.Length));
Assert.Equal(dec.Length, Base32Encoding.DecodedLength(enc));
Assert.Equal(0, Array_.Compare(data, 0, data.Length, dec, 0, dec.Length));
}
}
public bool Validate(string code, string secret)
{
if (string.IsNullOrEmpty(code))
{
throw new ArgumentNullException(nameof(code));
}
if (string.IsNullOrEmpty(secret))
{
throw new ArgumentNullException(nameof(secret));
}
var secretBase32 = Base32String
.Encode(Encoding.UTF8.GetBytes(secret));
var totpProvider = new Totp(
secretKey: Base32Encoding.ToBytes(secretBase32),
mode: OtpHashMode.Sha256,
step: 30);
return(totpProvider.VerifyTotp(
DateTime.UtcNow,
code,
out _,
VerificationWindow.RfcSpecifiedNetworkDelay));
}
/// <summary>
/// 随机生成google验证 base32密钥
/// </summary>
/// <param name="length">种子长度</param>
/// <returns></returns>
public string GoogleKeyForRand(int length = 10)
{
var keys = KeyGeneration.GenerateRandomKey(length);
var keystr = Base32Encoding.ToString(keys);
return(keystr);
}
private async Task <Result <ValidateAppMfaCodeAgainstCurrentUserCommandResult, ErrorData> > Process(
ValidateAppMfaCodeAgainstCurrentUserCommand request,
CancellationToken cancellationToken)
{
var currentUserMaybe = this._currentAuthenticatedUserProvider.CurrentAuthenticatedUser;
if (currentUserMaybe.HasNoValue)
{
return(Result.Fail <ValidateAppMfaCodeAgainstCurrentUserCommandResult, ErrorData>(new ErrorData(ErrorCodes.UserNotFound)));
}
var userMaybe = await this._userRepository.Find(currentUserMaybe.Value.UserId, cancellationToken);
if (userMaybe.HasNoValue)
{
return(Result.Fail <ValidateAppMfaCodeAgainstCurrentUserCommandResult, ErrorData>(new ErrorData(ErrorCodes.UserNotFound)));
}
var user = userMaybe.Value;
var authApp = user.AuthenticatorApps.SingleOrDefault(x => x.WhenRevoked == null);
if (authApp == null)
{
return(Result.Fail <ValidateAppMfaCodeAgainstCurrentUserCommandResult, ErrorData>(new ErrorData(ErrorCodes.NoAuthenticatorAppEnrolled)));
}
var secretBytes = Base32Encoding.ToBytes(authApp.Key);
var topt = new Totp(secretBytes);
var isVerified = topt.VerifyTotp(request.Code, out _);
return(isVerified
? Result.Ok <ValidateAppMfaCodeAgainstCurrentUserCommandResult, ErrorData>(new ValidateAppMfaCodeAgainstCurrentUserCommandResult(user.Id))
: Result.Fail <ValidateAppMfaCodeAgainstCurrentUserCommandResult, ErrorData>(new ErrorData(ErrorCodes.MfaCodeNotValid)));
}
public string GenerateSecretKey()
{
var key = KeyGeneration.GenerateRandomKey(_SecretKeyLength);
var base32String = Base32Encoding.ToString(key);
return(base32String.Replace("=", ""));
}
private async Task<ResultWithError<ErrorData>> Process(
EnrollAuthenticatorAppCommand request, CancellationToken cancellationToken)
{
var currentUserMaybe = this._currentAuthenticatedUserProvider.CurrentAuthenticatedUser;
if (currentUserMaybe.HasValue && currentUserMaybe.Value is AuthenticatedUser currentUser)
{
var userMaybe = await this._userRepository.Find(currentUser.UserId, cancellationToken);
if (userMaybe.HasNoValue)
{
return ResultWithError.Fail(new ErrorData(ErrorCodes.UserNotFound));
}
var user = userMaybe.Value;
if (user.AuthenticatorApps.Any(x => x.WhenRevoked == null))
{
return ResultWithError.Fail(new ErrorData(ErrorCodes.AuthenticatorAppAlreadyEnrolled));
}
var secretBytes = Base32Encoding.ToBytes(request.Key);
var topt = new Totp(secretBytes);
var isVerified = topt.VerifyTotp(request.Code, out _);
if (!isVerified)
{
return ResultWithError.Fail(new ErrorData(ErrorCodes.FailedVerifyingAuthenticatorCode));
}
user.EnrollAuthenticatorApp(Guid.NewGuid(), request.Key, this._clock.GetCurrentInstant().ToDateTimeUtc());
return ResultWithError.Ok<ErrorData>();
}
return ResultWithError.Fail(new ErrorData(ErrorCodes.UserNotFound));
}
private DirInfo CreateDirInfo(string physicalDirFile, string base64Ciphertext, DirInfo parent)
{
var filename = DecryptFileName(physicalDirFile, parent.ParentDirId);
string[] lines = File.ReadAllLines(PathJoin(physicalDirFile, "dir.c9r"));
string dirID = lines[0];
Debug.Assert(lines[0].Length == 36 && lines.Length == 1);
var dirIdHash =
Base32Encoding.ToString(sha1.ComputeHash(siv.Seal(Encoding.UTF8.GetBytes(dirID))));
Debug.Assert(dirIdHash.Length == 32);
var actualDirPath = PathJoin(dirIdHash.Substring(0, 2), dirIdHash.Substring(2));
return(new DirInfo
{
Name = filename,
VirtualPath = PathJoin(parent.VirtualPath, filename),
PhysicalPath = PathJoin(vaultPath, "d", actualDirPath),
ParentDirId = dirID,
Level = parent.Level + 1
});
}
public async Task <IActionResult> Configuration()
{
if (!Request.Form.ContainsKey("Email"))
{
return(Unauthorized());
}
var email = Request.Form
.Where(x => x.Key == "Email")
.Select(x => x.Value)
.FirstOrDefault()
.ToString()
.Clean();
if (string.IsNullOrEmpty(email))
{
return(Unauthorized());
}
var user = await _userManager.FindByEmailAsync(email);
if (user == null)
{
return(Unauthorized());
}
// check for existing token
var existingToken = user.Tokens.Where(x => x.LoginProvider == "Two-Factor").FirstOrDefault();
if (existingToken != null)
{
user.Tokens.Remove(existingToken);
}
// generate new token
var secret = Base32Encoding.ToString(KeyGeneration.GenerateRandomKey(20));
user.TwoFactorEnabled = true;
user.Tokens.Add(new IdentityUserToken <string>()
{
LoginProvider = "Two-Factor",
Name = user.Email,
UserId = user.Id,
Value = secret
});
var identityResult = await _userManager.UpdateAsync(user);
if (!identityResult.Succeeded)
{
_logger.Exception(new Exception(identityResult.Errors.First().Description));
return(BadRequest(identityResult.Errors.First().Description));
}
ViewData["Email"] = user.Email;
ViewData["Token"] = secret;
ViewData["LoginUrl"] = _appSettings.Application.MainSiteUrlTrim + "/Account/Login";
return(View());
}
public static Authenticator FromOtpAuthMigrationAuthenticator(OtpAuthMigration.Authenticator input)
{
string issuer;
string username;
// Google Auth may not have an issuer, just use the username instead
if (String.IsNullOrEmpty(input.Issuer))
{
issuer = input.Username.Trim().Truncate(32);
username = null;
}
else
{
issuer = input.Issuer.Trim().Truncate(32);
// For some odd reason the username field always follows a '[issuer]: [username]' format
username = input.Username.Replace($"{input.Issuer}: ", "").Trim().Truncate(40);
}
var type = input.Type switch
{
OtpAuthMigration.Type.Totp => AuthenticatorType.Totp,
OtpAuthMigration.Type.Hotp => AuthenticatorType.Hotp,
_ => throw new InvalidAuthenticatorException()
};
var algorithm = input.Algorithm switch
{
OtpAuthMigration.Algorithm.Sha1 => OtpHashMode.Sha1,
_ => throw new InvalidAuthenticatorException()
};
string secret;
try
{
secret = Base32Encoding.ToString(input.Secret);
secret = CleanSecret(secret);
}
catch
{
throw new InvalidAuthenticatorException();
}
var auth = new Authenticator()
{
Issuer = issuer,
Username = username,
Algorithm = algorithm,
Type = type,
Secret = secret,
Counter = input.Counter,
Digits = DefaultDigits,
Period = DefaultPeriod,
Icon = Shared.Data.Icon.FindServiceKeyByName(issuer)
};
auth.Validate();
return(auth);
}
public Task <bool> ValidateAsync(string purpose, string token, UserManager <UserInfo> manager, UserInfo user)
{
var otp = new Totp(Base32Encoding.ToBytes(user.DualAuthenticationSecretKey));
long timeStepMatched = 0;
var isValid = otp.VerifyTotp(token, out timeStepMatched, new VerificationWindow(1, 1));
return(Task.FromResult(isValid));
}
private string GetTOTPCode(string token)
{
var bytes = Base32Encoding.ToBytes(token);
var totp = new Totp(bytes);
return(totp.ComputeTotp());
}
public static string GetTTH(string filePath, out byte[][][] tigerTree)
{
lock (_hashCalculator)
{
tigerTree = _hashCalculator.GetTTHTree(filePath);
return(Base32Encoding.ToString(tigerTree[tigerTree.GetLength(0) - 1][0]));
}
}
public void TestCtor()
{
try // null alphabet
{
var x = new Base32Encoding(null);
Assert.Fail(typeof(ArgumentNullException).ToString());
}
catch (ArgumentNullException)
{
}
try // bad length alphabet
{
var x = new Base32Encoding("1245645");
Assert.Fail(typeof(ArgumentException).ToString());
}
catch (ArgumentException)
{
}
try // look-up table null
{
var x = new Base32Encoding(Base32Encoding.Hex.Alphabet, (Byte[]) null);
Assert.Fail(typeof(ArgumentNullException).ToString());
}
catch (ArgumentNullException)
{
}
try // look-up table bad length
{
var x = new Base32Encoding(Base32Encoding.Hex.Alphabet, new Byte[20]);
Assert.Fail(typeof(ArgumentNullException).ToString());
}
catch (ArgumentException)
{
}
}
public static TryResult<String> TryToBase32String(Value128 data, Base32Encoding base32Encoding)
{
if (base32Encoding == null)
{
return encodeFailResult;
}
Char[] result;
// Get padding symbol
var paddingSymbol = base32Encoding.PaddingSymbol;
if (paddingSymbol.HasValue)
{
result = new Char[32];
// Set padding
result[26] = result[27] = result[28] = result[29] = result[30] = result[31] = paddingSymbol.Value;
}
else
{
result = new Char[26];
}
var higherHalf = data.HigherHalf;
var lowerHalf = data.LowerHalf;
// Get alphabet
var alphabet = base32Encoding.Alphabet;
for (Int32 indexH = 0, indexL = 13, shiftH = 59, shiftL = 58; indexH < 12; indexH++, indexL++, shiftH -= 5, shiftL -= 5)
{
result[indexH] = alphabet[(Int32) (higherHalf >> shiftH) & 0x1F];
result[indexL] = alphabet[(Int32) (lowerHalf >> shiftL) & 0x1F];
}
result[12] = alphabet[(Int32) (((higherHalf << 1) & 0x1E) | ((lowerHalf >> 63) & 0x01))];
result[25] = alphabet[(Int32) ((lowerHalf << 2) & 0x1C)];
return TryResult<String>.CreateSuccess(new String(result));
}
public static TryResult<Value128> TryFromBase32String(String data, Int32 offset, Base32Encoding base32Encoding)
{
// Check input values
if ((data == null) || (offset > data.Length - base32EncodedSymbolsCount) || (base32Encoding == null))
{
return convertFailResult;
}
// Get look-up table
var lookupTable = base32Encoding.LookupTable;
var lastIndex = offset + 12;
var symbol12 = (UInt64) lookupTable[data[lastIndex] & 0x7F];
var symbol25 = (UInt64) lookupTable[data[offset + 25] & 0x7F];
// Check symbol
if ((symbol12 | symbol25) == 0xFF)
{
return convertFailResult;
}
// Calculate higher half
var higherHalf = symbol12 >> 1;
// Calculate lower half
var lowerHalf = symbol12 << 63 | symbol25 >> 2;
// Decode symbols
for (Int32 indexH = offset, indexL = offset + 13, shiftH = 59, shiftL = 58; indexH < lastIndex; indexH++, indexL++, shiftH -= 5, shiftL -= 5)
{
// Get symbols
var symbolH = data[indexH] & 0x7F;
var symbolL = data[indexL] & 0x7F;
// Get symbols values
var symbolHValue = (UInt64) lookupTable[symbolH];
var symbolLValue = (UInt64) lookupTable[symbolL];
// Check symbol
if ((symbolHValue | symbolLValue) == 0xFF)
{
return convertFailResult;
}
higherHalf |= symbolHValue << shiftH;
lowerHalf |= symbolLValue << shiftL;
}
// Initialize a new instance
var result = new Value128(higherHalf, lowerHalf);
return TryResult<Value128>.CreateSuccess(result);
}
