10 examples of 'angular decode jwt' in JavaScript

41
function decodeJwt(token) {
42
    const parts = token.split('.');
43
44
    if (parts.length !== 3) {
45
        throw new Error('JWT must have 3 parts');
46
    }
47
48
    let payload = parts[1].replace(/-/g, '+').replace(/_/g, '/');
49
    switch (payload.length % 4) {
50
        case 0: { break; }
51
        case 2: { payload += '=='; break; }
52
        case 3: { payload += '='; break; }
53
        default: {
54
            throw 'Illegal base64url string!';
55
        }
56
    }
57
58
    const decodedPayload = $window.decodeURIComponent($window.escape($window.atob(payload)));
59
    if (!decodedPayload) {
60
        throw new Error('Cannot decode the token');
61
    }
62
63
    return JSON.parse(decodedPayload);
64
}

1
export default function decodeJWT (token) {
2
  const base64Url = token.split('.')[1];
3
  const base64 = base64Url.replace(/-/g, '+').replace(/_/g, '/');
4
  const buff = window.nodeAPI.Buffer.from(base64, 'base64');  
5
  const ascii = buff.toString('ascii');
6
  const jsonPayload = decodeURIComponent(ascii.split('').map(function(c) {
7
    return '%' + ('00' + c.charCodeAt(0).toString(16)).slice(-2);
8
  }).join(''));
9
10
  return JSON.parse(jsonPayload);
11
}

15
export function decodeJWT(str: string) {
16
  const parts = str.split('.');
17
  if (parts.length < 2) {
18
    return null;
19
  }
20
  return {
21
    header: decodeBase64Url(parts[0]),
22
    payload: decodeBase64Url(parts[1]),
23
    signature: parts[2]
24
  };
25
}

35
function parseJwt(token: any): string {
36
  var base64Url = token.split('.')[1];
37
  var base64 = base64Url.replace(/-/g, '+').replace(/_/g, '/');
38
  return JSON.parse(window.atob(base64));
39
};

41
function decode(token) {
42
    try {
43
        const decoded = jwt.verify(token, secretKey);
44
        if (decoded.iss != ISSUER) {
45
            throw new ccxtRestErrors.AuthError(`Invalid issuer ${decoded.iss}`)
46
        }
47
        return decoded      
48
    } catch (error) {
49
        console.trace(error)
50
        throw new ccxtRestErrors.InvalidTokenError(`Invalid token ${token}`)
51
    }
52
}

10
function parseJwt(rawJwt) {
11
  try {
12
    return jwt.verify(rawJwt, process.env.JWT_SECRET)
13
  } catch (e) {
14
    console.log(e)
15
    return null
16
  }
17
}

119
public decodeToken(token: string): any {
120
121
    const parts = token.split('.');
122
123
    if (parts.length !== 3) {
124
        throw new Error('JWT must have 3 parts');
125
    }
126
127
    const decoded = this.urlBase64Decode(parts[1]);
128
    if (!decoded) {
129
        throw new Error('Cannot decode the token');
130
    }
131
132
    return JSON.parse(decoded);
133
}

46
decode(token) {
47
  if (!this.isValid(token)) {
48
    return {}
49
  }
50
51
  try {
52
    return jwtDecode(token);
53
  } catch (err) {
54
    return {}
55
  }
56
}

17
static decodeJwt(jwtToken: string): any {
18
    if (StringUtils.isEmpty(jwtToken)) {
19
        throw ClientAuthError.createIdTokenNullOrEmptyError(jwtToken);
20
    }
21
    const idTokenPartsRegex = /^([^\.\s]*)\.([^\.\s]+)\.([^\.\s]*)$/;
22
    const matches = idTokenPartsRegex.exec(jwtToken);
23
    if (!matches || matches.length < 4) {
24
        throw ClientAuthError.createIdTokenParsingError(`Given token is malformed: ${jwtToken}`);
25
    }
26
    const crackedToken = {
27
        header: matches[1],
28
        JWSPayload: matches[2],
29
        JWSSig: matches[3]
30
    };
31
    return crackedToken;
32
}

46
export function verifyJwt(token) {
47
  return jwt.verify(token, secrets.jwt);
48
}