kript.swagger.json

{
  "swagger": "2.0",
  "info": {
    "title": "kript/api/account.proto",
    "version": "1.0"
  },
  "schemes": [
    "https"
  ],
  "consumes": [
    "application/json"
  ],
  "produces": [
    "application/json"
  ],
  "paths": {
    "/account/change-password": {
      "post": {
        "summary": "Change the user's password.",
        "operationId": "AccountService_UpdatePassword",
        "responses": {
          "200": {
            "description": "A successful response.",
            "schema": {
              "$ref": "#/definitions/apiUpdatePasswordResponse"
            }
          },
          "default": {
            "description": "An unexpected error response",
            "schema": {
              "$ref": "#/definitions/runtimeError"
            }
          }
        },
        "parameters": [
          {
            "name": "body",
            "in": "body",
            "required": true,
            "schema": {
              "$ref": "#/definitions/apiUpdatePasswordRequest"
            }
          }
        ],
        "tags": [
          "AccountService"
        ]
      }
    },
    "/account/create": {
      "post": {
        "summary": "Create an account.",
        "operationId": "AccountService_CreateAccount",
        "responses": {
          "200": {
            "description": "A successful response.",
            "schema": {
              "$ref": "#/definitions/apiCreateAccountResponse"
            }
          },
          "default": {
            "description": "An unexpected error response",
            "schema": {
              "$ref": "#/definitions/runtimeError"
            }
          }
        },
        "parameters": [
          {
            "name": "body",
            "in": "body",
            "required": true,
            "schema": {
              "$ref": "#/definitions/apiCreateAccountRequest"
            }
          }
        ],
        "tags": [
          "AccountService"
        ]
      }
    },
    "/account/two-factor": {
      "post": {
        "summary": "Request to add the given two-factor destination and send a confirmation\ncode to the two-factor destination.",
        "operationId": "AccountService_AddTwoFactor",
        "responses": {
          "200": {
            "description": "A successful response.",
            "schema": {
              "$ref": "#/definitions/apiAddTwoFactorResponse"
            }
          },
          "default": {
            "description": "An unexpected error response",
            "schema": {
              "$ref": "#/definitions/runtimeError"
            }
          }
        },
        "parameters": [
          {
            "name": "body",
            "in": "body",
            "required": true,
            "schema": {
              "$ref": "#/definitions/apiAddTwoFactorRequest"
            }
          }
        ],
        "tags": [
          "AccountService"
        ]
      }
    },
    "/account/two-factor/verify": {
      "post": {
        "summary": "Verify a two-factor destination.",
        "operationId": "AccountService_VerifyTwoFactor",
        "responses": {
          "200": {
            "description": "A successful response.",
            "schema": {
              "$ref": "#/definitions/apiVerifyTwoFactorResponse"
            }
          },
          "default": {
            "description": "An unexpected error response",
            "schema": {
              "$ref": "#/definitions/runtimeError"
            }
          }
        },
        "parameters": [
          {
            "name": "body",
            "in": "body",
            "required": true,
            "schema": {
              "$ref": "#/definitions/apiVerifyTwoFactorRequest"
            }
          }
        ],
        "tags": [
          "AccountService"
        ]
      }
    },
    "/auth/login": {
      "post": {
        "summary": "Login the user. If the user has 2-factor authentication enabled,\na verification code must be sent with SendVerification to complete the\nlogin process.",
        "operationId": "AccountService_LoginUser",
        "responses": {
          "200": {
            "description": "A successful response.",
            "schema": {
              "$ref": "#/definitions/apiLoginUserResponse"
            }
          },
          "default": {
            "description": "An unexpected error response",
            "schema": {
              "$ref": "#/definitions/runtimeError"
            }
          }
        },
        "parameters": [
          {
            "name": "body",
            "in": "body",
            "required": true,
            "schema": {
              "$ref": "#/definitions/apiLoginUserRequest"
            }
          }
        ],
        "tags": [
          "AccountService"
        ]
      }
    },
    "/auth/refresh": {
      "post": {
        "summary": "Fetch a new access token.",
        "operationId": "AccountService_RefreshAuth",
        "responses": {
          "200": {
            "description": "A successful response.",
            "schema": {
              "$ref": "#/definitions/apiRefreshAuthResponse"
            }
          },
          "default": {
            "description": "An unexpected error response",
            "schema": {
              "$ref": "#/definitions/runtimeError"
            }
          }
        },
        "parameters": [
          {
            "name": "body",
            "in": "body",
            "required": true,
            "schema": {
              "$ref": "#/definitions/apiRefreshAuthRequest"
            }
          }
        ],
        "tags": [
          "AccountService"
        ]
      }
    },
    "/auth/verify": {
      "post": {
        "summary": "Complete logging in the user.",
        "operationId": "AccountService_VerifyUser",
        "responses": {
          "200": {
            "description": "A successful response.",
            "schema": {
              "$ref": "#/definitions/apiVerifyUserResponse"
            }
          },
          "default": {
            "description": "An unexpected error response",
            "schema": {
              "$ref": "#/definitions/runtimeError"
            }
          }
        },
        "parameters": [
          {
            "name": "body",
            "in": "body",
            "required": true,
            "schema": {
              "$ref": "#/definitions/apiVerifyUserRequest"
            }
          }
        ],
        "tags": [
          "AccountService"
        ]
      }
    },
    "/auth/verify/send": {
      "post": {
        "summary": "Send a verification code to the user using the specified method.",
        "operationId": "AccountService_SendVerification",
        "responses": {
          "200": {
            "description": "A successful response.",
            "schema": {
              "$ref": "#/definitions/apiSendVerificationResponse"
            }
          },
          "default": {
            "description": "An unexpected error response",
            "schema": {
              "$ref": "#/definitions/runtimeError"
            }
          }
        },
        "parameters": [
          {
            "name": "body",
            "in": "body",
            "required": true,
            "schema": {
              "$ref": "#/definitions/apiSendVerificationRequest"
            }
          }
        ],
        "tags": [
          "AccountService"
        ]
      }
    },
    "/data": {
      "get": {
        "summary": "Get the list of all data for the logged in user, or a specific datum if\nspecified.",
        "operationId": "DataService_GetData",
        "responses": {
          "200": {
            "description": "A successful response.",
            "schema": {
              "$ref": "#/definitions/apiGetDataResponse"
            }
          },
          "default": {
            "description": "An unexpected error response",
            "schema": {
              "$ref": "#/definitions/runtimeError"
            }
          }
        },
        "parameters": [
          {
            "name": "access_token.jwt.token",
            "description": "The Base 64 encoded JWT.",
            "in": "query",
            "required": false,
            "type": "string"
          },
          {
            "name": "datum_ids",
            "description": "The list of ids of datums to retrieve. If empty, all datums that the user\nhas access to will be retrieved.",
            "in": "query",
            "required": false,
            "type": "array",
            "items": {
              "type": "string"
            },
            "collectionFormat": "multi"
          }
        ],
        "tags": [
          "DataService"
        ]
      },
      "delete": {
        "summary": "Delete the specified datum.",
        "operationId": "DataService_DeleteDatum",
        "responses": {
          "200": {
            "description": "A successful response.",
            "schema": {
              "$ref": "#/definitions/apiDeleteDatumResponse"
            }
          },
          "default": {
            "description": "An unexpected error response",
            "schema": {
              "$ref": "#/definitions/runtimeError"
            }
          }
        },
        "parameters": [
          {
            "name": "access_token.jwt.token",
            "description": "The Base 64 encoded JWT.",
            "in": "query",
            "required": false,
            "type": "string"
          },
          {
            "name": "id",
            "description": "The id of the datum to delete.",
            "in": "query",
            "required": false,
            "type": "string"
          }
        ],
        "tags": [
          "DataService"
        ]
      },
      "post": {
        "summary": "Create a new datum.",
        "operationId": "DataService_CreateDatum",
        "responses": {
          "200": {
            "description": "A successful response.",
            "schema": {
              "$ref": "#/definitions/apiCreateDatumResponse"
            }
          },
          "default": {
            "description": "An unexpected error response",
            "schema": {
              "$ref": "#/definitions/runtimeError"
            }
          }
        },
        "parameters": [
          {
            "name": "body",
            "in": "body",
            "required": true,
            "schema": {
              "$ref": "#/definitions/apiCreateDatumRequest"
            }
          }
        ],
        "tags": [
          "DataService"
        ]
      },
      "patch": {
        "summary": "Update the specified datum with new data.",
        "operationId": "DataService_UpdateDatum",
        "responses": {
          "200": {
            "description": "A successful response.",
            "schema": {
              "$ref": "#/definitions/apiUpdateDatumResponse"
            }
          },
          "default": {
            "description": "An unexpected error response",
            "schema": {
              "$ref": "#/definitions/runtimeError"
            }
          }
        },
        "parameters": [
          {
            "name": "body",
            "in": "body",
            "required": true,
            "schema": {
              "$ref": "#/definitions/apiUpdateDatumRequest"
            }
          }
        ],
        "tags": [
          "DataService"
        ]
      }
    },
    "/data/share": {
      "post": {
        "summary": "Share a datum with another user by granting them new permission(s) on it.",
        "operationId": "DataService_ShareDatum",
        "responses": {
          "200": {
            "description": "A successful response.",
            "schema": {
              "$ref": "#/definitions/apiShareDatumResponse"
            }
          },
          "default": {
            "description": "An unexpected error response",
            "schema": {
              "$ref": "#/definitions/runtimeError"
            }
          }
        },
        "parameters": [
          {
            "name": "body",
            "in": "body",
            "required": true,
            "schema": {
              "$ref": "#/definitions/apiShareDatumRequest"
            }
          }
        ],
        "tags": [
          "DataService"
        ]
      }
    },
    "/user": {
      "get": {
        "summary": "Get the information of the user with the given username or user id.\nIf the user is the logged in user, the private user information is\nincluded.",
        "operationId": "AccountService_GetUser",
        "responses": {
          "200": {
            "description": "A successful response.",
            "schema": {
              "$ref": "#/definitions/apiGetUserResponse"
            }
          },
          "default": {
            "description": "An unexpected error response",
            "schema": {
              "$ref": "#/definitions/runtimeError"
            }
          }
        },
        "parameters": [
          {
            "name": "access_token.jwt.token",
            "description": "The Base 64 encoded JWT.",
            "in": "query",
            "required": false,
            "type": "string"
          },
          {
            "name": "username",
            "description": "The username of the user.",
            "in": "query",
            "required": false,
            "type": "string"
          },
          {
            "name": "user_id",
            "description": "The id of the user.",
            "in": "query",
            "required": false,
            "type": "string"
          }
        ],
        "tags": [
          "AccountService"
        ]
      }
    }
  },
  "definitions": {
    "AccessMetadataPermissionGrantMetadata": {
      "type": "object",
      "properties": {
        "granter_id": {
          "type": "string",
          "description": "The id of the user who granted or revoked a permission."
        },
        "permission": {
          "$ref": "#/definitions/apiPermission",
          "description": "The permission that was granted or revoked."
        },
        "is_grant": {
          "type": "boolean",
          "format": "boolean",
          "description": "If true, this grant was a grant. Otherwise, it was a revoke."
        }
      },
      "description": "Metadata associated with a change in access permissions."
    },
    "DatumAccess": {
      "type": "object",
      "properties": {
        "user_id": {
          "type": "string",
          "description": "The id of the user whom this access object is associated with."
        },
        "data_key": {
          "$ref": "#/definitions/apiEBytes",
          "description": "The key used to encrypt the actual data, encrypted using this user's\npublic key and decrypted with their private key."
        },
        "permissions": {
          "type": "array",
          "items": {
            "$ref": "#/definitions/apiPermission"
          },
          "description": "The list of permissions this user has on this datum."
        }
      },
      "description": "An object representing relevant data to a user who has access to this\ndatum."
    },
    "DatumMetadata": {
      "type": "object",
      "properties": {
        "owner_id": {
          "type": "string",
          "description": "The user who created and owns this datum."
        },
        "created_time": {
          "type": "string",
          "format": "date-time",
          "description": "The time at which this datum was created."
        },
        "last_edited": {
          "type": "string",
          "format": "date-time",
          "description": "The time at which this datum was last modified."
        },
        "access_metadata": {
          "type": "object",
          "additionalProperties": {
            "$ref": "#/definitions/MetadataAccessMetadata"
          },
          "description": "A map of id of users with access or who once had access to metadata\nassociated with that access."
        }
      },
      "description": "The metadata associated with this datum."
    },
    "LoginUserResponseTwoFactorInfo": {
      "type": "object",
      "properties": {
        "verification_token": {
          "$ref": "#/definitions/apiVerificationToken",
          "description": "The token used to identify the user through the verification process."
        },
        "options": {
          "type": "object",
          "additionalProperties": {
            "$ref": "#/definitions/apiTwoFactor"
          },
          "description": "The options available for two-factor authentication, where the key is the\nid of the option."
        }
      },
      "description": "Represents the relevant information for the two-factor authentication\nprocess to continue."
    },
    "MetadataAccessMetadata": {
      "type": "object",
      "properties": {
        "grant_metadata": {
          "type": "array",
          "items": {
            "$ref": "#/definitions/AccessMetadataPermissionGrantMetadata"
          },
          "description": "The grants and revokes that have been given to the user."
        }
      },
      "description": "Metadata associated with a user who had access to this datum at some\npoint."
    },
    "apiAEncryptionAlgorithm": {
      "type": "string",
      "enum": [
        "UNKNOWN_A_ENCRYPTION_ALGORITHM",
        "RSA"
      ],
      "default": "UNKNOWN_A_ENCRYPTION_ALGORITHM",
      "description": "An enumeration of different asymmetric encryption algorithms.\n\n - RSA: Encrypt/Decrypt using RSA with OAEP padding."
    },
    "apiAccessToken": {
      "type": "object",
      "properties": {
        "jwt": {
          "$ref": "#/definitions/apiJWT"
        }
      }
    },
    "apiAddTwoFactorRequest": {
      "type": "object",
      "properties": {
        "access_token": {
          "$ref": "#/definitions/apiAccessToken",
          "description": "The access token to identify and authenticate the user."
        },
        "two_factor": {
          "$ref": "#/definitions/apiTwoFactor",
          "description": "The two-factor authentication method to add."
        }
      }
    },
    "apiAddTwoFactorResponse": {
      "type": "object",
      "properties": {
        "verification_token": {
          "$ref": "#/definitions/apiVerificationToken",
          "description": "The token used to identify the verification code flow."
        }
      }
    },
    "apiCreateAccountRequest": {
      "type": "object",
      "properties": {
        "username": {
          "type": "string",
          "description": "The username of the user."
        },
        "password": {
          "$ref": "#/definitions/apiHString",
          "description": "The hashed password of the user."
        },
        "salt": {
          "type": "string",
          "format": "byte",
          "description": "The salt used in the new hashed password."
        },
        "password_hash_algorithm": {
          "$ref": "#/definitions/apiHashAlgorithm",
          "description": "The hashing algorithm used to hash the user's password."
        },
        "public_key": {
          "type": "string",
          "format": "byte",
          "description": "The user's public key."
        },
        "private_key": {
          "$ref": "#/definitions/apiEBytes",
          "description": "The user's private key, encrypted using the user's password."
        },
        "data_encryption_algorithm": {
          "$ref": "#/definitions/apiAEncryptionAlgorithm",
          "description": "The encryption algorithm used to encrypt the user's data."
        },
        "private_key_encryption_algorithm": {
          "$ref": "#/definitions/apiSEncryptionAlgorithm",
          "description": "The encryption algorithm used to encrypt the user's private key."
        },
        "private_key_iv": {
          "type": "string",
          "format": "byte",
          "description": "The initialization vector used to encrypt the private key."
        },
        "private_key_key_salt": {
          "type": "string",
          "format": "byte",
          "description": "The salt used in generating the key for encrypting/decrypting the private key."
        },
        "private_key_key_hash_algorithm": {
          "$ref": "#/definitions/apiHashAlgorithm",
          "description": "The hash algorithm used to generate the key for encrypting/decrypting the private key."
        }
      }
    },
    "apiCreateAccountResponse": {
      "type": "object",
      "properties": {
        "response": {
          "$ref": "#/definitions/apiSuccessfulLoginMessage",
          "description": "The user's authentication and information."
        }
      }
    },
    "apiCreateDatumRequest": {
      "type": "object",
      "properties": {
        "access_token": {
          "$ref": "#/definitions/apiAccessToken",
          "description": "The access token to identify and authenticate the user."
        },
        "title": {
          "type": "string",
          "title": "The title of the datum. (Optional)"
        },
        "data": {
          "$ref": "#/definitions/apiESecret",
          "description": "The actual data of the datum, such as a password or code, encrypted.\nThis should decrypt to a string of a json object."
        },
        "data_key": {
          "$ref": "#/definitions/apiEBytes",
          "description": "The key used to encrypt the actual data, encrypted using the owner's\npublic key and decrypted with their private key."
        },
        "data_encryption_algorithm": {
          "$ref": "#/definitions/apiSEncryptionAlgorithm",
          "description": "The encryption algorithm used to encrypt the actual data."
        },
        "data_iv": {
          "type": "string",
          "format": "byte",
          "description": "The initialization vector used to encrypt the data."
        }
      }
    },
    "apiCreateDatumResponse": {
      "type": "object",
      "properties": {
        "datum": {
          "$ref": "#/definitions/apiDatum",
          "description": "The created datum."
        }
      }
    },
    "apiDatum": {
      "type": "object",
      "properties": {
        "id": {
          "type": "string",
          "description": "The identifier of this datum."
        },
        "owner": {
          "type": "string",
          "description": "The owner of this datum."
        },
        "data": {
          "$ref": "#/definitions/apiESecret",
          "description": "The actual data of this datum, such as a password or code, encrypted."
        },
        "data_encryption_algorithm": {
          "$ref": "#/definitions/apiSEncryptionAlgorithm",
          "description": "The encryption algorithm used to encrypt the actual data."
        },
        "data_iv": {
          "type": "string",
          "format": "byte",
          "description": "The initialization vector used to encrypt the data."
        },
        "accessors": {
          "type": "object",
          "additionalProperties": {
            "$ref": "#/definitions/DatumAccess"
          },
          "description": "A map of ids of users who have access to this datum to information on what\npermissions they have. This does not include the owner, who has all permissions."
        },
        "metadata": {
          "$ref": "#/definitions/DatumMetadata",
          "description": "The metadata associated with this datum."
        }
      }
    },
    "apiDeleteDatumResponse": {
      "type": "object",
      "properties": {
        "datum": {
          "$ref": "#/definitions/apiDatum",
          "description": "The deleted datum, as it was before deletion."
        }
      }
    },
    "apiEBytes": {
      "type": "object",
      "properties": {
        "data": {
          "type": "string",
          "format": "byte",
          "description": "The byte string encrypted."
        }
      },
      "description": "A byte string that has been encrypted."
    },
    "apiESecret": {
      "type": "object",
      "properties": {
        "data": {
          "type": "string",
          "format": "byte",
          "description": "The Secret object ecnrypted, using protobuf encoding."
        }
      },
      "description": "A Secret object that has been encrypted."
    },
    "apiGetDataResponse": {
      "type": "object",
      "properties": {
        "datums": {
          "type": "array",
          "items": {
            "$ref": "#/definitions/apiDatum"
          },
          "description": "The datums requested by the user."
        }
      }
    },
    "apiGetUserResponse": {
      "type": "object",
      "properties": {
        "user": {
          "$ref": "#/definitions/apiUser",
          "description": "The information of the specified user."
        }
      }
    },
    "apiHString": {
      "type": "object",
      "properties": {
        "data": {
          "type": "string",
          "format": "byte",
          "description": "The string hashed, using utf-8 encoding."
        }
      },
      "description": "A string that has been hashed."
    },
    "apiHashAlgorithm": {
      "type": "string",
      "enum": [
        "UNKNOWN_HASH_ALGORITHM",
        "SCRYPT",
        "PBKDF2_SHA_512",
        "ARGON2"
      ],
      "default": "UNKNOWN_HASH_ALGORITHM",
      "description": "An enumeration of different password hashing algorithms.\n\n - SCRYPT: Hash the utf-8 encoded password and utf-8 encoded salt using scrypt with N=16384, r=8, p=1, and derived key length = 256 bits\n - PBKDF2_SHA_512: Hash the utf-8 encoded password and utf-8 encoded salt using PBKDF2 with SHA512, 20000 iterations, and a derived key length of 256 bits\n - ARGON2: Hash the utf-8 encoded password and utf-8 encoded salt using Argon2id, with t=75, m=1024, p=1, T=32 (derived key length of 256 bits)."
    },
    "apiJWT": {
      "type": "object",
      "properties": {
        "token": {
          "type": "string",
          "description": "The Base 64 encoded JWT."
        }
      },
      "description": "A representation of a JSON Web Token."
    },
    "apiLoginUserRequest": {
      "type": "object",
      "properties": {
        "username": {
          "type": "string",
          "description": "The username of the user."
        },
        "user_id": {
          "type": "string",
          "description": "The id of the user."
        },
        "password": {
          "$ref": "#/definitions/apiHString",
          "description": "The hashed password of the user."
        }
      }
    },
    "apiLoginUserResponse": {
      "type": "object",
      "properties": {
        "two_factor": {
          "$ref": "#/definitions/LoginUserResponseTwoFactorInfo",
          "description": "The two-factor authentication information if two-factor authentication\nis enabled."
        },
        "response": {
          "$ref": "#/definitions/apiSuccessfulLoginMessage",
          "description": "The user's authentication and information if two-factor authentication\nis disabled."
        }
      }
    },
    "apiPermission": {
      "type": "string",
      "enum": [
        "UNKNOWN",
        "READ",
        "WRITE",
        "DELETE",
        "SHARE",
        "ADMIN"
      ],
      "default": "UNKNOWN",
      "description": "A permission that a user can have on a datum.\n\n - READ: Permission to read the datum.\n - WRITE: Permission to read and write the datum.\n - DELETE: Permission to read and delete the datum.\n - SHARE: Permission to read and share the datum with other users. The user has the power\nto share the same permissions that they have.\n - ADMIN: Full permission on the datum."
    },
    "apiPrivateUser": {
      "type": "object",
      "properties": {
        "private_key": {
          "$ref": "#/definitions/apiEBytes",
          "description": "The user's private key, encrypted with the user's password."
        },
        "private_key_encryption_algorithm": {
          "$ref": "#/definitions/apiSEncryptionAlgorithm",
          "description": "The encryption algorithm used to encrypt the private key."
        },
        "private_key_iv": {
          "type": "string",
          "format": "byte",
          "description": "The initialization vector used to encrypt the private key."
        },
        "private_key_key_salt": {
          "type": "string",
          "format": "byte",
          "description": "The salt used in generating the key for encrypting/decrypting the private key."
        },
        "private_key_key_hash_algorithm": {
          "$ref": "#/definitions/apiHashAlgorithm",
          "description": "The hash algorithm used to generate the key for encrypting/decrypting the private key."
        }
      },
      "description": "Private information about a user that is only visible to the user."
    },
    "apiPublicUser": {
      "type": "object",
      "properties": {
        "id": {
          "type": "string",
          "description": "The id of the user."
        },
        "username": {
          "type": "string",
          "description": "The username of the user."
        },
        "public_key": {
          "type": "string",
          "format": "byte",
          "description": "The user's public key."
        },
        "password_salt": {
          "type": "string",
          "format": "byte",
          "description": "The salt used to hash the user's password."
        },
        "password_hash_algorithm": {
          "$ref": "#/definitions/apiHashAlgorithm",
          "description": "The hashing algorithm used to hash the user's password."
        },
        "data_encryption_algorithm": {
          "$ref": "#/definitions/apiAEncryptionAlgorithm",
          "description": "The encryption algorithm used to encrypt the user's data keys."
        }
      },
      "description": "The public information about a user that is visible to anyone."
    },
    "apiRefreshAuthRequest": {
      "type": "object",
      "properties": {
        "refresh_token": {
          "$ref": "#/definitions/apiRefreshToken",
          "description": "The refresh token to identify and authenticate the user."
        }
      }
    },
    "apiRefreshAuthResponse": {
      "type": "object",
      "properties": {
        "access_token": {
          "$ref": "#/definitions/apiAccessToken",
          "description": "The access token to identify and authenticate the user."
        }
      }
    },
    "apiRefreshToken": {
      "type": "object",
      "properties": {
        "jwt": {
          "$ref": "#/definitions/apiJWT"
        }
      }
    },
    "apiSEncryptionAlgorithm": {
      "type": "string",
      "enum": [
        "UNKNOWN_S_ENCRYPTION_ALGORITHM",
        "AES_256_CBC",
        "AES_256_GCM"
      ],
      "default": "UNKNOWN_S_ENCRYPTION_ALGORITHM",
      "description": "An enumeration of different symmetric encryption algorithms.\n\n - AES_256_CBC: Encrypt using AES-256 with a given key and initialization vector, using CBC and PKCS7 padding. If the key is longer than 256 bits or the iv is longer than 128 bits, they are truncated. If they are shorter, they are zero-padded.\n - AES_256_GCM: Encrypt using AES-256 with a given key and initialization vector, using GCM and having a 16-byte authentication tag appended to the cyphertext. If the key is longer than 256 bits or the iv is longer than 128 bits, they are truncated. If they are shorter, they are zero-padded."
    },
    "apiSendVerificationRequest": {
      "type": "object",
      "properties": {
        "verification_token": {
          "$ref": "#/definitions/apiVerificationToken",
          "description": "The token used to identify the user through the verification process."
        },
        "two_factor_option_id": {
          "type": "string",
          "description": "The id of the two-factor authentication option used."
        }
      }
    },
    "apiSendVerificationResponse": {
      "type": "object",
      "properties": {
        "success": {
          "type": "boolean",
          "format": "boolean",
          "description": "Whether or not sending the verification code was successful."
        },
        "destination": {
          "$ref": "#/definitions/apiTwoFactor",
          "description": "The two-factor authentication option used."
        }
      }
    },
    "apiShareDatumRequest": {
      "type": "object",
      "properties": {
        "access_token": {
          "$ref": "#/definitions/apiAccessToken",
          "description": "The access token to identify and authenticate the user."
        },
        "id": {
          "type": "string",
          "description": "The id of the datum to share."
        },
        "target_id": {
          "type": "string",
          "description": "The id of the user the datum should be shared with."
        },
        "data_key": {
          "$ref": "#/definitions/apiEBytes",
          "description": "The key used to encrypt the actual data, encrypted using the target user's\npublic key and decrypted with their private key."
        },
        "permissions": {
          "type": "array",
          "items": {
            "$ref": "#/definitions/apiPermission"
          },
          "description": "The permissions to be granted to this user. These are in addition to any\npermissions the user already has."
        }
      }
    },
    "apiShareDatumResponse": {
      "type": "object",
      "properties": {
        "datum": {
          "$ref": "#/definitions/apiDatum",
          "description": "The shared datum."
        }
      }
    },
    "apiSuccessfulLoginMessage": {
      "type": "object",
      "properties": {
        "refresh_token": {
          "$ref": "#/definitions/apiRefreshToken",
          "description": "The refresh token to identify and authenticate the user."
        },
        "access_token": {
          "$ref": "#/definitions/apiAccessToken",
          "description": "The access token to identify and authenticate the user."
        },
        "user": {
          "$ref": "#/definitions/apiUser",
          "description": "The user's information."
        }
      }
    },
    "apiTwoFactor": {
      "type": "object",
      "properties": {
        "type": {
          "$ref": "#/definitions/apiTwoFactorType",
          "description": "The type of two-factor authentication."
        },
        "destination": {
          "type": "string",
          "description": "Where the two-factor authentication code is sent (phone, email, etc.)."
        }
      },
      "description": "A way to send/receive a two-factor authentication code."
    },
    "apiTwoFactorType": {
      "type": "string",
      "enum": [
        "UNKNOWN_TWO_FACTOR_TYPE",
        "PHONE_TEXT",
        "PHONE_CALL",
        "EMAIL"
      ],
      "default": "UNKNOWN_TWO_FACTOR_TYPE",
      "description": "An enumeration of type of two-factor authentication.\n\n - PHONE_TEXT: A code via text message. This method is not yet supported.\n - PHONE_CALL: A code via phone call.\n - EMAIL: A code via email. This method is not yet supported."
    },
    "apiUpdateDatumRequest": {
      "type": "object",
      "properties": {
        "access_token": {
          "$ref": "#/definitions/apiAccessToken",
          "description": "The access token to identify and authenticate the user."
        },
        "id": {
          "type": "string",
          "description": "The id of the datum to update."
        },
        "title": {
          "type": "string",
          "title": "The new title of the datum. (Optional)"
        },
        "data": {
          "$ref": "#/definitions/apiESecret",
          "description": "The new actual data of the datum, such as a password or code, encrypted.\nThis should decrypt to a string of a json object."
        },
        "data_iv": {
          "type": "string",
          "format": "byte",
          "description": "The new initialization vector used to encrypt the data."
        }
      }
    },
    "apiUpdateDatumResponse": {
      "type": "object",
      "properties": {
        "datum": {
          "$ref": "#/definitions/apiDatum",
          "description": "The updated datum."
        }
      }
    },
    "apiUpdatePasswordRequest": {
      "type": "object",
      "properties": {
        "access_token": {
          "$ref": "#/definitions/apiAccessToken",
          "description": "The access token to identify and authenticate the user."
        },
        "old_password": {
          "$ref": "#/definitions/apiHString",
          "description": "The old hashed password of the user."
        },
        "new_password": {
          "$ref": "#/definitions/apiHString",
          "description": "The new hashed password of the user."
        },
        "new_salt": {
          "type": "string",
          "format": "byte",
          "description": "The salt used in the new hashed password."
        },
        "new_password_hash_algorithm": {
          "$ref": "#/definitions/apiHashAlgorithm",
          "description": "The hashing algorithm used to hash the user's new password."
        },
        "private_key": {
          "$ref": "#/definitions/apiEBytes",
          "description": "The user's private key, re-encrypted with the user's new password."
        },
        "private_key_encryption_algorithm": {
          "$ref": "#/definitions/apiSEncryptionAlgorithm",
          "description": "The encryption algorithm used to encrypt the user's private key."
        },
        "private_key_iv": {
          "type": "string",
          "format": "byte",
          "description": "The initialization vector used to encrypt the private key."
        },
        "private_key_key_salt": {
          "type": "string",
          "format": "byte",
          "description": "The new salt used in generating the key for encrypting/decrypting the private key."
        },
        "private_key_key_hash_algorithm": {
          "$ref": "#/definitions/apiHashAlgorithm",
          "description": "The new hash algorithm used to generate the key for encrypting/decrypting the private key."
        }
      }
    },
    "apiUpdatePasswordResponse": {
      "type": "object",
      "properties": {
        "user": {
          "$ref": "#/definitions/apiUser",
          "description": "The user's information."
        }
      }
    },
    "apiUser": {
      "type": "object",
      "properties": {
        "public": {
          "$ref": "#/definitions/apiPublicUser",
          "description": "The user's public information."
        },
        "private": {
          "$ref": "#/definitions/apiPrivateUser",
          "description": "The user's private information."
        }
      },
      "description": "The public and private information about a user."
    },
    "apiVerificationToken": {
      "type": "object",
      "properties": {
        "jwt": {
          "$ref": "#/definitions/apiJWT"
        }
      }
    },
    "apiVerifyTwoFactorRequest": {
      "type": "object",
      "properties": {
        "verification_token": {
          "$ref": "#/definitions/apiVerificationToken",
          "description": "The token used to identify the verification code flow."
        },
        "code": {
          "type": "string",
          "description": "The two-factor authentication code received on the specified destination."
        }
      }
    },
    "apiVerifyTwoFactorResponse": {
      "type": "object",
      "properties": {
        "two_factor": {
          "$ref": "#/definitions/apiTwoFactor",
          "description": "The successfully added two-factor authentication method."
        }
      }
    },
    "apiVerifyUserRequest": {
      "type": "object",
      "properties": {
        "verification_token": {
          "$ref": "#/definitions/apiVerificationToken",
          "description": "The token used to identify the user through the verification process."
        },
        "code": {
          "type": "string",
          "description": "The two-factor authentication code received on the specified destination."
        }
      }
    },
    "apiVerifyUserResponse": {
      "type": "object",
      "properties": {
        "response": {
          "$ref": "#/definitions/apiSuccessfulLoginMessage",
          "description": "The user's authentication and information."
        }
      }
    },
    "protobufAny": {
      "type": "object",
      "properties": {
        "type_url": {
          "type": "string",
          "description": "A URL/resource name that uniquely identifies the type of the serialized\nprotocol buffer message. This string must contain at least\none \"/\" character. The last segment of the URL's path must represent\nthe fully qualified name of the type (as in\n`path/google.protobuf.Duration`). The name should be in a canonical form\n(e.g., leading \".\" is not accepted).\n\nIn practice, teams usually precompile into the binary all types that they\nexpect it to use in the context of Any. However, for URLs which use the\nscheme `http`, `https`, or no scheme, one can optionally set up a type\nserver that maps type URLs to message definitions as follows:\n\n* If no scheme is provided, `https` is assumed.\n* An HTTP GET on the URL must yield a [google.protobuf.Type][]\n  value in binary format, or produce an error.\n* Applications are allowed to cache lookup results based on the\n  URL, or have them precompiled into a binary to avoid any\n  lookup. Therefore, binary compatibility needs to be preserved\n  on changes to types. (Use versioned type names to manage\n  breaking changes.)\n\nNote: this functionality is not currently available in the official\nprotobuf release, and it is not used for type URLs beginning with\ntype.googleapis.com.\n\nSchemes other than `http`, `https` (or the empty scheme) might be\nused with implementation specific semantics."
        },
        "value": {
          "type": "string",
          "format": "byte",
          "description": "Must be a valid serialized protocol buffer of the above specified type."
        }
      },
      "description": "`Any` contains an arbitrary serialized protocol buffer message along with a\nURL that describes the type of the serialized message.\n\nProtobuf library provides support to pack/unpack Any values in the form\nof utility functions or additional generated methods of the Any type.\n\nExample 1: Pack and unpack a message in C++.\n\n    Foo foo = ...;\n    Any any;\n    any.PackFrom(foo);\n    ...\n    if (any.UnpackTo(\u0026foo)) {\n      ...\n    }\n\nExample 2: Pack and unpack a message in Java.\n\n    Foo foo = ...;\n    Any any = Any.pack(foo);\n    ...\n    if (any.is(Foo.class)) {\n      foo = any.unpack(Foo.class);\n    }\n\n Example 3: Pack and unpack a message in Python.\n\n    foo = Foo(...)\n    any = Any()\n    any.Pack(foo)\n    ...\n    if any.Is(Foo.DESCRIPTOR):\n      any.Unpack(foo)\n      ...\n\n Example 4: Pack and unpack a message in Go\n\n     foo := \u0026pb.Foo{...}\n     any, err := ptypes.MarshalAny(foo)\n     ...\n     foo := \u0026pb.Foo{}\n     if err := ptypes.UnmarshalAny(any, foo); err != nil {\n       ...\n     }\n\nThe pack methods provided by protobuf library will by default use\n'type.googleapis.com/full.type.name' as the type URL and the unpack\nmethods only use the fully qualified type name after the last '/'\nin the type URL, for example \"foo.bar.com/x/y.z\" will yield type\nname \"y.z\".\n\n\nJSON\n====\nThe JSON representation of an `Any` value uses the regular\nrepresentation of the deserialized, embedded message, with an\nadditional field `@type` which contains the type URL. Example:\n\n    package google.profile;\n    message Person {\n      string first_name = 1;\n      string last_name = 2;\n    }\n\n    {\n      \"@type\": \"type.googleapis.com/google.profile.Person\",\n      \"firstName\": \u003cstring\u003e,\n      \"lastName\": \u003cstring\u003e\n    }\n\nIf the embedded message type is well-known and has a custom JSON\nrepresentation, that representation will be embedded adding a field\n`value` which holds the custom JSON in addition to the `@type`\nfield. Example (for message [google.protobuf.Duration][]):\n\n    {\n      \"@type\": \"type.googleapis.com/google.protobuf.Duration\",\n      \"value\": \"1.212s\"\n    }"
    },
    "runtimeError": {
      "type": "object",
      "properties": {
        "error": {
          "type": "string"
        },
        "code": {
          "type": "integer",
          "format": "int32"
        },
        "message": {
          "type": "string"
        },
        "details": {
          "type": "array",
          "items": {
            "$ref": "#/definitions/protobufAny"
          }
        }
      }
    }
  },
  "externalDocs": {
    "description": "Kript",
    "url": "https://github.com/liam923/Kript"
  }
}