Lisoveliy/TOTPFit
1
0
Fork 0
Code Issues 3 Pull Requests Actions Packages Projects Releases Wiki Activity

Compare commits

base: Lisoveliy:dev
Branches Tags
Lisoveliy:main
Lisoveliy:dev
..
compare: Lisoveliy:main
Branches Tags
Lisoveliy:dev
Lisoveliy:main

No commits in common. "dev" and "main" have entirely different histories.
dev ... main

8 changed files with 12 additions and 286 deletions
Show Stats Expand all files Collapse all files

2
app.json
View File

@ -6,7 +6,7 @@
"appType": "app", "appType": "app",
"version": { "version": {
"code": 1, "code": 1,
"name": "1.1.3" "name": "1.1.1"
}, },
"icon": "icon.png", "icon": "icon.png",
"vender": "zepp", "vender": "zepp",

36
lib/protobuf-decoder/hexUtils.js
View File

@ -1,36 +0,0 @@
import { Buffer } from 'buffer'
export function parseInput(input) {
const normalizedInput = input.replace(/\s/g, "");
const normalizedHexInput = normalizedInput.replace(/0x/g, "").toLowerCase();
if (isHex(normalizedHexInput)) {
return Buffer.from(normalizedHexInput, "hex");
} else {
return Buffer.from(normalizedInput, "base64");
}
}
export function isHex(string) {
let result = true;
for (const char of string) {
if (!((char >= "a" && char <= "f") || (char >= "0" && char <= "9"))) {
result = false;
}
}
return result;
}
export function bufferLeToBeHex(buffer) {
let output = "";
for (const v of buffer) {
const hex = v.toString(16);
if (hex.length === 1) {
output = "0" + hex + output;
} else {
output = hex + output;
}
}
return output;
}
export const bufferToPrettyHex = b => [...b].map(c => c.toString(16).padStart(2, '0')).join(' ');

27
lib/protobuf-decoder/intUtils.js
View File

@ -1,27 +0,0 @@
import JSBI from "jsbi";
export function interpretAsSignedType(n) {
// see https://github.com/protocolbuffers/protobuf/blob/master/src/google/protobuf/wire_format_lite.h#L857-L876
// however, this is a simpler equivalent formula
const isEven = JSBI.equal(JSBI.bitwiseAnd(n, JSBI.BigInt(1)), JSBI.BigInt(0));
if (isEven) {
return JSBI.divide(n, JSBI.BigInt(2));
} else {
return JSBI.multiply(
JSBI.BigInt(-1),
JSBI.divide(JSBI.add(n, JSBI.BigInt(1)), JSBI.BigInt(2))
);
}
}
export function interpretAsTwosComplement(n, bits) {
const isTwosComplement = JSBI.equal(
JSBI.signedRightShift(n, JSBI.BigInt(bits - 1)),
JSBI.BigInt(1)
);
if (isTwosComplement) {
return JSBI.subtract(n, JSBI.leftShift(JSBI.BigInt(1), JSBI.BigInt(bits)));
} else {
return n;
}
}

132
lib/protobuf-decoder/protobufDecoder.js
View File

@ -1,132 +0,0 @@
import { decodeVarint } from "./varintUtils";
export class BufferReader {
constructor(buffer) {
this.buffer = buffer;
this.offset = 0;
}
readVarInt() {
const result = decodeVarint(this.buffer, this.offset);
this.offset += result.length;
return result.value;
}
readBuffer(length) {
this.checkByte(length);
const result = this.buffer.slice(this.offset, this.offset + length);
this.offset += length;
return result;
}
// gRPC has some additional header - remove it
trySkipGrpcHeader() {
const backupOffset = this.offset;
if (this.buffer[this.offset] === 0 && this.leftBytes() >= 5) {
this.offset++;
const length = this.buffer.readInt32BE(this.offset);
this.offset += 4;
if (length > this.leftBytes()) {
// Something is wrong, revert
this.offset = backupOffset;
}
}
}
leftBytes() {
return this.buffer.length - this.offset;
}
checkByte(length) {
const bytesAvailable = this.leftBytes();
if (length > bytesAvailable) {
throw new Error(
"Not enough bytes left. Requested: " +
length +
" left: " +
bytesAvailable
);
}
}
checkpoint() {
this.savedOffset = this.offset;
}
resetToCheckpoint() {
this.offset = this.savedOffset;
}
}
export const TYPES = {
VARINT: 0,
FIXED64: 1,
LENDELIM: 2,
FIXED32: 5
};
export function decodeProto(buffer) {
const reader = new BufferReader(buffer);
const parts = [];
reader.trySkipGrpcHeader();
try {
while (reader.leftBytes() > 0) {
reader.checkpoint();
const byteRange = [reader.offset];
const indexType = parseInt(reader.readVarInt().toString());
const type = indexType & 0b111;
const index = indexType >> 3;
let value;
if (type === TYPES.VARINT) {
value = reader.readVarInt().toString();
} else if (type === TYPES.LENDELIM) {
const length = parseInt(reader.readVarInt().toString());
value = reader.readBuffer(length);
} else if (type === TYPES.FIXED32) {
value = reader.readBuffer(4);
} else if (type === TYPES.FIXED64) {
value = reader.readBuffer(8);
} else {
throw new Error("Unknown type: " + type);
}
byteRange.push(reader.offset);
parts.push({
byteRange,
index,
type,
value
});
}
} catch (err) {
reader.resetToCheckpoint();
}
return {
parts,
leftOver: reader.readBuffer(reader.leftBytes())
};
}
export function typeToString(type, subType) {
switch (type) {
case TYPES.VARINT:
return "varint";
case TYPES.LENDELIM:
return subType || "len_delim";
case TYPES.FIXED32:
return "fixed32";
case TYPES.FIXED64:
return "fixed64";
default:
return "unknown";
}
}

24
lib/protobuf-decoder/varintUtils.js
View File

@ -1,24 +0,0 @@
"use bigint"
export function decodeVarint(buffer, offset) {
let res = BigInt(0);
let shift = 0;
let byte = 0;
do {
if (offset >= buffer.length) {
throw new RangeError("Index out of bound decoding varint");
}
byte = buffer[offset++];
const multiplier = exponentiate(BigInt(2), BigInt(shift));
const thisByteValue = multiply(BigInt(byte & 0x7f), multiplier);
shift += 7;
res = add(res, thisByteValue);
} while (byte >= 0x80);
return {
value: res,
length: shift / 7
};
}

28
lib/totp-quickjs/base32decoder.js
View File

@ -23,32 +23,4 @@ function leftpad(str, len, pad) {
(str = new Array(len + 1 - str.length).join(pad) + str), (str = new Array(len + 1 - str.length).join(pad) + str),
str str
); );
}
export function base64decode(base64) {
const chars = "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/";
let result = [];
let i = 0, j = 0;
let b1, b2, b3, b4;
while (i < base64.length) {
b1 = chars.indexOf(base64.charAt(i++));
b2 = chars.indexOf(base64.charAt(i++));
b3 = chars.indexOf(base64.charAt(i++));
b4 = chars.indexOf(base64.charAt(i++));
if (b1 === -1 || b2 === -1) break;
result[j++] = (b1 << 2) | (b2 >> 4);
if (b3 !== -1) {
result[j++] = ((b2 & 15) << 4) | (b3 >> 2);
}
if (b4 !== -1) {
result[j++] = ((b3 & 3) << 6) | b4;
}
}
return result.slice(0, j);
} }

2
package.json
View File

@ -1,6 +1,6 @@
{ {
"name": "totpfit", "name": "totpfit",
"version": "1.1.3", "version": "1.1.1",
"description": "Another 2FAuthenticator based on TOTP for Zepp Amazfit GTS 4", "description": "Another 2FAuthenticator based on TOTP for Zepp Amazfit GTS 4",
"main": "app.js", "main": "app.js",
"author": "Lisoveliy", "author": "Lisoveliy",

47
setting/utils/queryParser.js
View File

@ -1,29 +1,10 @@
import { decodeProto } from "../../lib/protobuf-decoder/protobufDecoder";
import { TOTP } from "../../lib/totp-quickjs"; import { TOTP } from "../../lib/totp-quickjs";
import { base64decode } from "../../lib/totp-quickjs/base32decoder";
const otpauthScheme = "otpauth:/"; const otpScheme = "otpauth:/";
const googleMigrationScheme = "otpauth-migration:/";
export function getTOTPByLink(link) { export function getTOTPByLink(link) {
if(link.includes(otpauthScheme))
return getByOtpauthScheme(link)
if(link.includes(googleMigrationScheme))
return getByGoogleMigrationScheme(link)
return null;
}
function getHashType(algorithm) {
if (algorithm == "SHA1") return "SHA-1";
if (algorithm == "SHA256") return "SHA-256";
if (algorithm == "SHA512") return "SHA-512";
else return "SHA-1";
}
function getByOtpauthScheme(link){
try { try {
let args = link.split("/", otpauthScheme.length); let args = link.split("/", otpScheme.length);
let type = args[2]; //Returns 'hotp' or 'totp' let type = args[2]; //Returns 'hotp' or 'totp'
let issuer = args[3].split(":")[0]?.split("?")[0]; //Returns issuer let issuer = args[3].split(":")[0]?.split("?")[0]; //Returns issuer
let client = let client =
@ -39,12 +20,8 @@ function getByOtpauthScheme(link){
if (secret === undefined) throw new Error("Secret not defined"); if (secret === undefined) throw new Error("Secret not defined");
if(issuer == client){ issuer = issuer.replace("%20", " ");
issuer = args[3].split("issuer=")[1]?.split("&")[0] client = client.replace("%20", " ");
}
issuer = decodeURIComponent(issuer);
client = decodeURIComponent(client);
return new TOTP( return new TOTP(
secret, secret,
@ -56,17 +33,13 @@ function getByOtpauthScheme(link){
getHashType(algorithm) getHashType(algorithm)
); );
} catch (err) { } catch (err) {
console.log(err)
return null; return null;
} }
} }
function getByGoogleMigrationScheme(link){ function getHashType(algorithm) {
console.log("Hello") if (algorithm == "SHA1") return "SHA-1";
let data = link.split("data=")[1]; //Returns secret if (algorithm == "SHA256") return "SHA-256";
data = decodeURIComponent(data); if (algorithm == "SHA512") return "SHA-512";
console.log(data) else return "SHA-1";
let decode = base64decode(data); }
console.log(decode)
console.log(decodeProto(decode));
}