Page MenuHomePhabricator
Differential D7647

[native] Calculate SHA256 of encrypted blob
ClosedPublic
Actions

Authored by bartek on Apr 27 2023, 3:53 AM.
Tags
None
Referenced Files
Unknown Object (File)
Sun, Mar 30, 9:40 PM
Unknown Object (File)
Sat, Mar 15, 4:45 PM
Unknown Object (File)
Thu, Mar 6, 6:35 AM
Unknown Object (File)
Wed, Mar 5, 9:35 PM
Unknown Object (File)
Wed, Mar 5, 9:35 PM
Unknown Object (File)
Wed, Mar 5, 9:34 PM
Unknown Object (File)
Wed, Mar 5, 9:34 PM
Unknown Object (File)
Wed, Mar 5, 9:28 PM
View All Files
Subscribers
ashoat
tomek

Details

Reviewers
atul
marcin
Commits
rCOMMde360ffea5af: [native] Calculate SHA256 of encrypted blob
Summary

We need the blob hash in order to upload the encrypted blob to Blob service.
According to whitepaper, we use SHA256 to calculate the hash of encrypted blob.

Exposed the calculated SHA256 within encryption result payload.

Test Plan

Added console.log and sent encrypted video message. Verified that both video and thumbnail have blobHash field.

Diff Detail

Repository
rCOMM Comm
Lint
No Lint Coverage
Unit
No Test Coverage

Event Timeline

bartek created this revision.Apr 27 2023, 3:53 AM
bartek held this revision as a draft.
Herald added subscribers: tomek, ashoat. · View Herald TranscriptApr 27 2023, 3:53 AM
Harbormaster completed remote builds in B18841: Diff 25810.Apr 27 2023, 4:11 AM
bartek added a child revision: D7650: [native] Upload encrypted media to Blob service.Apr 27 2023, 4:29 AM
bartek published this revision for review.Apr 27 2023, 4:36 AM
bartek added inline comments.
web/media/encryption-utils.js
72 ↗(On Diff #25810)

This will be set in one of the web-part stack diffs

bartek mentioned this in D7688: [web] Caclulate encrypted media sha256.Apr 29 2023, 9:16 AM
atul accepted this revision.May 3 2023, 10:45 AM
atul added inline comments.
lib/types/media-types.js
270 ↗(On Diff #25810)

We need the blob hash in order to upload the encrypted blob to Blob service.

Should sha256 be string instead of ?string?

EDIT: Looks like we can make this string after web/media/encryption-utils.js is updated?

native/media/encryption-utils.js
110–115 ↗(On Diff #25810)

Would it make sense to have a different reason instead of "encryption_failed" if computing sha256 fails (not sure in what scenario this would happen)?

185–189 ↗(On Diff #25810)

We could destructure these fields from encryptionResult, but whatever you prefer

This revision is now accepted and ready to land.May 3 2023, 10:45 AM
bartek added inline comments.May 8 2023, 12:22 AM
lib/types/media-types.js
270 ↗(On Diff #25810)

Yes, I'll do that in the web diff for this

native/media/encryption-utils.js
110–115 ↗(On Diff #25810)

Sure, will do

bartek added inline comments.May 8 2023, 12:57 AM
native/media/encryption-utils.js
185–189 ↗(On Diff #25810)

In this case, I'd prefer not to because this function is already too long and this wouldn't improve readability IMO

bartek updated this revision to Diff 26176.May 8 2023, 4:03 AM

Rebase before landing

Harbormaster completed remote builds in B19122: Diff 26176.May 8 2023, 4:25 AM
Closed by commit rCOMMde360ffea5af: [native] Calculate SHA256 of encrypted blob (authored by bartek). · Explain WhyMay 8 2023, 4:47 AM
This revision was automatically updated to reflect the committed changes.
bartek added a commit: rCOMMde360ffea5af: [native] Calculate SHA256 of encrypted blob.
bartek mentioned this in rCOMMb62c392ba505: [web] Caclulate encrypted media sha256.May 9 2023, 7:02 AM

Revision Contents
Changeset List

PathSize
lib/
types/
4 lines
native/
media/
14 lines
3 lines
web/
media/
1 line

Diff 26176

View Options

lib/types/media-types.js

// @flow // @flow
import t, { type TInterface, type TUnion } from 'tcomb'; import t, { type TInterface, type TUnion } from 'tcomb';
import { import {
tHexEncodedPermissionsBitmask, tHexEncodedPermissionsBitmask,
tHexEncodedRolePermission, tHexEncodedRolePermission,
} from './minimally-encoded-thread-permissions.js'; } from './minimally-encoded-thread-permissions.js';
import { specialRoleValidator } from './special-roles.js'; import { specialRoleValidator } from './special-roles.js';
import type { import type {
MemberInfo, MemberInfoWithPermissions,
ThreadCurrentUserInfo, ThreadCurrentUserInfo,
RawThreadInfo, RawThreadInfo,
RoleInfo, RoleInfo,
RoleInfoWithoutSpecialRole, RoleInfoWithoutSpecialRole,
RawThreadInfoWithoutSpecialRole, RawThreadInfoWithoutSpecialRole,
} from '../types/minimally-encoded-thread-permissions-types.js'; } from '../types/minimally-encoded-thread-permissions-types.js';
import { import {
type LegacyRawThreadInfo, type LegacyRawThreadInfo,
Show All 37 Lines tShape<RoleInfoPossiblyWithIsDefaultField>({
id: tID, id: tID,
name: t.String, name: t.String,
minimallyEncoded: tBool(true), minimallyEncoded: tBool(true),
permissions: t.list(tHexEncodedRolePermission), permissions: t.list(tHexEncodedRolePermission),
specialRole: t.maybe(specialRoleValidator), specialRole: t.maybe(specialRoleValidator),
isDefault: t.maybe(t.Boolean), isDefault: t.maybe(t.Boolean),
}); });
const memberInfoValidator: TInterface<MemberInfo> = tShape<MemberInfo>({ const memberInfoWithPermissionsValidator: TInterface<MemberInfoWithPermissions> =
tShape<MemberInfoWithPermissions>({
...legacyMemberInfoValidator.meta.props, ...legacyMemberInfoValidator.meta.props,
minimallyEncoded: tBool(true), minimallyEncoded: tBool(true),
permissions: tHexEncodedPermissionsBitmask, permissions: tHexEncodedPermissionsBitmask,
}); });
const rawThreadInfoValidator: TInterface<RawThreadInfo> = tShape<RawThreadInfo>( const rawThreadInfoValidator: TInterface<RawThreadInfo> = tShape<RawThreadInfo>(
{ {
...legacyRawThreadInfoValidator.meta.props, ...legacyRawThreadInfoValidator.meta.props,
minimallyEncoded: tBool(true), minimallyEncoded: tBool(true),
members: t.list(memberInfoValidator), members: t.list(memberInfoWithPermissionsValidator),
roles: t.dict(tID, roleInfoValidator), roles: t.dict(tID, roleInfoValidator),
currentUser: threadCurrentUserInfoValidator, currentUser: threadCurrentUserInfoValidator,
}, },
); );
const roleInfoWithoutSpecialRolesValidator: TInterface<RoleInfoWithoutSpecialRole> = const roleInfoWithoutSpecialRolesValidator: TInterface<RoleInfoWithoutSpecialRole> =
tShape<RoleInfoWithoutSpecialRole>({ tShape<RoleInfoWithoutSpecialRole>({
...roleInfoValidatorBase, ...roleInfoValidatorBase,
Show All 10 Linesconst mixedRawThreadInfoValidator: TUnion<
LegacyRawThreadInfo | RawThreadInfo | RawThreadInfoWithoutSpecialRole, LegacyRawThreadInfo | RawThreadInfo | RawThreadInfoWithoutSpecialRole,
> = t.union([ > = t.union([
legacyRawThreadInfoValidator, legacyRawThreadInfoValidator,
rawThreadInfoValidator, rawThreadInfoValidator,
rawThreadInfoWithoutSpecialRoles, rawThreadInfoWithoutSpecialRoles,
]); ]);
export { export {
memberInfoValidator, memberInfoWithPermissionsValidator,
roleInfoValidator, roleInfoValidator,
persistedRoleInfoValidator, persistedRoleInfoValidator,
threadCurrentUserInfoValidator, threadCurrentUserInfoValidator,
rawThreadInfoValidator, rawThreadInfoValidator,
mixedRawThreadInfoValidator, mixedRawThreadInfoValidator,
}; };
View Options

native/media/encryption-utils.js

// @flow // @flow
import t, { type TInterface, type TUnion } from 'tcomb'; import t, { type TInterface, type TUnion } from 'tcomb';
import { import {
tHexEncodedPermissionsBitmask, tHexEncodedPermissionsBitmask,
tHexEncodedRolePermission, tHexEncodedRolePermission,
} from './minimally-encoded-thread-permissions.js'; } from './minimally-encoded-thread-permissions.js';
import { specialRoleValidator } from './special-roles.js'; import { specialRoleValidator } from './special-roles.js';
import type { import type {
MemberInfo, MemberInfoWithPermissions,
ThreadCurrentUserInfo, ThreadCurrentUserInfo,
RawThreadInfo, RawThreadInfo,
RoleInfo, RoleInfo,
RoleInfoWithoutSpecialRole, RoleInfoWithoutSpecialRole,
RawThreadInfoWithoutSpecialRole, RawThreadInfoWithoutSpecialRole,
} from '../types/minimally-encoded-thread-permissions-types.js'; } from '../types/minimally-encoded-thread-permissions-types.js';
import { import {
type LegacyRawThreadInfo, type LegacyRawThreadInfo,
Show All 37 Lines tShape<RoleInfoPossiblyWithIsDefaultField>({
id: tID, id: tID,
name: t.String, name: t.String,
minimallyEncoded: tBool(true), minimallyEncoded: tBool(true),
permissions: t.list(tHexEncodedRolePermission), permissions: t.list(tHexEncodedRolePermission),
specialRole: t.maybe(specialRoleValidator), specialRole: t.maybe(specialRoleValidator),
isDefault: t.maybe(t.Boolean), isDefault: t.maybe(t.Boolean),
}); });
const memberInfoValidator: TInterface<MemberInfo> = tShape<MemberInfo>({ const memberInfoWithPermissionsValidator: TInterface<MemberInfoWithPermissions> =
tShape<MemberInfoWithPermissions>({
...legacyMemberInfoValidator.meta.props, ...legacyMemberInfoValidator.meta.props,
minimallyEncoded: tBool(true), minimallyEncoded: tBool(true),
permissions: tHexEncodedPermissionsBitmask, permissions: tHexEncodedPermissionsBitmask,
}); });
const rawThreadInfoValidator: TInterface<RawThreadInfo> = tShape<RawThreadInfo>( const rawThreadInfoValidator: TInterface<RawThreadInfo> = tShape<RawThreadInfo>(
{ {
...legacyRawThreadInfoValidator.meta.props, ...legacyRawThreadInfoValidator.meta.props,
minimallyEncoded: tBool(true), minimallyEncoded: tBool(true),
members: t.list(memberInfoValidator), members: t.list(memberInfoWithPermissionsValidator),
roles: t.dict(tID, roleInfoValidator), roles: t.dict(tID, roleInfoValidator),
currentUser: threadCurrentUserInfoValidator, currentUser: threadCurrentUserInfoValidator,
}, },
); );
const roleInfoWithoutSpecialRolesValidator: TInterface<RoleInfoWithoutSpecialRole> = const roleInfoWithoutSpecialRolesValidator: TInterface<RoleInfoWithoutSpecialRole> =
tShape<RoleInfoWithoutSpecialRole>({ tShape<RoleInfoWithoutSpecialRole>({
...roleInfoValidatorBase, ...roleInfoValidatorBase,
Show All 10 Linesconst mixedRawThreadInfoValidator: TUnion<
LegacyRawThreadInfo | RawThreadInfo | RawThreadInfoWithoutSpecialRole, LegacyRawThreadInfo | RawThreadInfo | RawThreadInfoWithoutSpecialRole,
> = t.union([ > = t.union([
legacyRawThreadInfoValidator, legacyRawThreadInfoValidator,
rawThreadInfoValidator, rawThreadInfoValidator,
rawThreadInfoWithoutSpecialRoles, rawThreadInfoWithoutSpecialRoles,
]); ]);
export { export {
memberInfoValidator, memberInfoWithPermissionsValidator,
roleInfoValidator, roleInfoValidator,
persistedRoleInfoValidator, persistedRoleInfoValidator,
threadCurrentUserInfoValidator, threadCurrentUserInfoValidator,
rawThreadInfoValidator, rawThreadInfoValidator,
mixedRawThreadInfoValidator, mixedRawThreadInfoValidator,
}; };
View Options

native/media/media-utils.js

// @flow // @flow
import t, { type TInterface, type TUnion } from 'tcomb'; import t, { type TInterface, type TUnion } from 'tcomb';
import { import {
tHexEncodedPermissionsBitmask, tHexEncodedPermissionsBitmask,
tHexEncodedRolePermission, tHexEncodedRolePermission,
} from './minimally-encoded-thread-permissions.js'; } from './minimally-encoded-thread-permissions.js';
import { specialRoleValidator } from './special-roles.js'; import { specialRoleValidator } from './special-roles.js';
import type { import type {
MemberInfo, MemberInfoWithPermissions,
ThreadCurrentUserInfo, ThreadCurrentUserInfo,
RawThreadInfo, RawThreadInfo,
RoleInfo, RoleInfo,
RoleInfoWithoutSpecialRole, RoleInfoWithoutSpecialRole,
RawThreadInfoWithoutSpecialRole, RawThreadInfoWithoutSpecialRole,
} from '../types/minimally-encoded-thread-permissions-types.js'; } from '../types/minimally-encoded-thread-permissions-types.js';
import { import {
type LegacyRawThreadInfo, type LegacyRawThreadInfo,
Show All 37 Lines tShape<RoleInfoPossiblyWithIsDefaultField>({
id: tID, id: tID,
name: t.String, name: t.String,
minimallyEncoded: tBool(true), minimallyEncoded: tBool(true),
permissions: t.list(tHexEncodedRolePermission), permissions: t.list(tHexEncodedRolePermission),
specialRole: t.maybe(specialRoleValidator), specialRole: t.maybe(specialRoleValidator),
isDefault: t.maybe(t.Boolean), isDefault: t.maybe(t.Boolean),
}); });
const memberInfoValidator: TInterface<MemberInfo> = tShape<MemberInfo>({ const memberInfoWithPermissionsValidator: TInterface<MemberInfoWithPermissions> =
tShape<MemberInfoWithPermissions>({
...legacyMemberInfoValidator.meta.props, ...legacyMemberInfoValidator.meta.props,
minimallyEncoded: tBool(true), minimallyEncoded: tBool(true),
permissions: tHexEncodedPermissionsBitmask, permissions: tHexEncodedPermissionsBitmask,
}); });
const rawThreadInfoValidator: TInterface<RawThreadInfo> = tShape<RawThreadInfo>( const rawThreadInfoValidator: TInterface<RawThreadInfo> = tShape<RawThreadInfo>(
{ {
...legacyRawThreadInfoValidator.meta.props, ...legacyRawThreadInfoValidator.meta.props,
minimallyEncoded: tBool(true), minimallyEncoded: tBool(true),
members: t.list(memberInfoValidator), members: t.list(memberInfoWithPermissionsValidator),
roles: t.dict(tID, roleInfoValidator), roles: t.dict(tID, roleInfoValidator),
currentUser: threadCurrentUserInfoValidator, currentUser: threadCurrentUserInfoValidator,
}, },
); );
const roleInfoWithoutSpecialRolesValidator: TInterface<RoleInfoWithoutSpecialRole> = const roleInfoWithoutSpecialRolesValidator: TInterface<RoleInfoWithoutSpecialRole> =
tShape<RoleInfoWithoutSpecialRole>({ tShape<RoleInfoWithoutSpecialRole>({
...roleInfoValidatorBase, ...roleInfoValidatorBase,
Show All 10 Linesconst mixedRawThreadInfoValidator: TUnion<
LegacyRawThreadInfo | RawThreadInfo | RawThreadInfoWithoutSpecialRole, LegacyRawThreadInfo | RawThreadInfo | RawThreadInfoWithoutSpecialRole,
> = t.union([ > = t.union([
legacyRawThreadInfoValidator, legacyRawThreadInfoValidator,
rawThreadInfoValidator, rawThreadInfoValidator,
rawThreadInfoWithoutSpecialRoles, rawThreadInfoWithoutSpecialRoles,
]); ]);
export { export {
memberInfoValidator, memberInfoWithPermissionsValidator,
roleInfoValidator, roleInfoValidator,
persistedRoleInfoValidator, persistedRoleInfoValidator,
threadCurrentUserInfoValidator, threadCurrentUserInfoValidator,
rawThreadInfoValidator, rawThreadInfoValidator,
mixedRawThreadInfoValidator, mixedRawThreadInfoValidator,
}; };
View Options

web/media/encryption-utils.js

// @flow // @flow
import t, { type TInterface, type TUnion } from 'tcomb'; import t, { type TInterface, type TUnion } from 'tcomb';
import { import {
tHexEncodedPermissionsBitmask, tHexEncodedPermissionsBitmask,
tHexEncodedRolePermission, tHexEncodedRolePermission,
} from './minimally-encoded-thread-permissions.js'; } from './minimally-encoded-thread-permissions.js';
import { specialRoleValidator } from './special-roles.js'; import { specialRoleValidator } from './special-roles.js';
import type { import type {
MemberInfo, MemberInfoWithPermissions,
ThreadCurrentUserInfo, ThreadCurrentUserInfo,
RawThreadInfo, RawThreadInfo,
RoleInfo, RoleInfo,
RoleInfoWithoutSpecialRole, RoleInfoWithoutSpecialRole,
RawThreadInfoWithoutSpecialRole, RawThreadInfoWithoutSpecialRole,
} from '../types/minimally-encoded-thread-permissions-types.js'; } from '../types/minimally-encoded-thread-permissions-types.js';
import { import {
type LegacyRawThreadInfo, type LegacyRawThreadInfo,
Show All 37 Lines tShape<RoleInfoPossiblyWithIsDefaultField>({
id: tID, id: tID,
name: t.String, name: t.String,
minimallyEncoded: tBool(true), minimallyEncoded: tBool(true),
permissions: t.list(tHexEncodedRolePermission), permissions: t.list(tHexEncodedRolePermission),
specialRole: t.maybe(specialRoleValidator), specialRole: t.maybe(specialRoleValidator),
isDefault: t.maybe(t.Boolean), isDefault: t.maybe(t.Boolean),
}); });
const memberInfoValidator: TInterface<MemberInfo> = tShape<MemberInfo>({ const memberInfoWithPermissionsValidator: TInterface<MemberInfoWithPermissions> =
tShape<MemberInfoWithPermissions>({
...legacyMemberInfoValidator.meta.props, ...legacyMemberInfoValidator.meta.props,
minimallyEncoded: tBool(true), minimallyEncoded: tBool(true),
permissions: tHexEncodedPermissionsBitmask, permissions: tHexEncodedPermissionsBitmask,
}); });
const rawThreadInfoValidator: TInterface<RawThreadInfo> = tShape<RawThreadInfo>( const rawThreadInfoValidator: TInterface<RawThreadInfo> = tShape<RawThreadInfo>(
{ {
...legacyRawThreadInfoValidator.meta.props, ...legacyRawThreadInfoValidator.meta.props,
minimallyEncoded: tBool(true), minimallyEncoded: tBool(true),
members: t.list(memberInfoValidator), members: t.list(memberInfoWithPermissionsValidator),
roles: t.dict(tID, roleInfoValidator), roles: t.dict(tID, roleInfoValidator),
currentUser: threadCurrentUserInfoValidator, currentUser: threadCurrentUserInfoValidator,
}, },
); );
const roleInfoWithoutSpecialRolesValidator: TInterface<RoleInfoWithoutSpecialRole> = const roleInfoWithoutSpecialRolesValidator: TInterface<RoleInfoWithoutSpecialRole> =
tShape<RoleInfoWithoutSpecialRole>({ tShape<RoleInfoWithoutSpecialRole>({
...roleInfoValidatorBase, ...roleInfoValidatorBase,
Show All 10 Linesconst mixedRawThreadInfoValidator: TUnion<
LegacyRawThreadInfo | RawThreadInfo | RawThreadInfoWithoutSpecialRole, LegacyRawThreadInfo | RawThreadInfo | RawThreadInfoWithoutSpecialRole,
> = t.union([ > = t.union([
legacyRawThreadInfoValidator, legacyRawThreadInfoValidator,
rawThreadInfoValidator, rawThreadInfoValidator,
rawThreadInfoWithoutSpecialRoles, rawThreadInfoWithoutSpecialRoles,
]); ]);
export { export {
memberInfoValidator, memberInfoWithPermissionsValidator,
roleInfoValidator, roleInfoValidator,
persistedRoleInfoValidator, persistedRoleInfoValidator,
threadCurrentUserInfoValidator, threadCurrentUserInfoValidator,
rawThreadInfoValidator, rawThreadInfoValidator,
mixedRawThreadInfoValidator, mixedRawThreadInfoValidator,
}; };