api.proto

// Copyright 2020 Teserakt AG
//
// Licensed under the Apache License, Version 2.0 (the "License");
// you may not use this file except in compliance with the License.
// You may obtain a copy of the License at
//
// http://www.apache.org/licenses/LICENSE-2.0
//
// Unless required by applicable law or agreed to in writing, software
// distributed under the License is distributed on an "AS IS" BASIS,
// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
// See the License for the specific language governing permissions and
// limitations under the License.

syntax = "proto3";
package pb;

import "google/api/annotations.proto";
import "protoc-gen-swagger/options/annotations.proto";
import "google/protobuf/timestamp.proto";

option (grpc.gateway.protoc_gen_swagger.options.openapiv2_swagger) = {
  host : "127.0.0.1:8888"
  info : {title : "c2-api";};

  schemes : HTTPS;
  consumes : "application/json";
  produces : "application/json";
};

service C2 {
  // Create a new client
  rpc NewClient(NewClientRequest) returns (NewClientResponse) {
    option (google.api.http) = {
      post : "/e4/client/{client.name}"
      body : "*"
    };
  }
  // Remove a client
  rpc RemoveClient(RemoveClientRequest) returns (RemoveClientResponse) {
    option (google.api.http) = {
      delete : "/e4/client/{client.name}"
    };
  }
  // Instruct the C2 server to send a reset command to the client
  rpc ResetClient(ResetClientRequest) returns (ResetClientResponse) {
    option (google.api.http) = {
      put : "/e4/client/{client.name}"
    };
  }
  // Generate a new key for the client
  rpc NewClientKey(NewClientKeyRequest) returns (NewClientKeyResponse) {
    option (google.api.http) = {
      patch : "/e4/client/{client.name}"
      body : "*"
    };
  }
  // Create a new topic
  rpc NewTopic(NewTopicRequest) returns (NewTopicResponse) {
    option (google.api.http) = {
      post : "/e4/topic/{topic=**}"
    };
  }
  // Remove a topic
  rpc RemoveTopic(RemoveTopicRequest) returns (RemoveTopicResponse) {
    option (google.api.http) = {
      delete : "/e4/topic/{topic=**}"
    };
  }
  // Associate a topic with a client
  rpc NewTopicClient(NewTopicClientRequest) returns (NewTopicClientResponse) {
    option (google.api.http) = {
      put : "/e4/client/{client.name}/topic/{topic=**}"
    };
  }
  // Remove a topic / client association
  rpc RemoveTopicClient(RemoveTopicClientRequest) returns (RemoveTopicClientResponse) {
    option (google.api.http) = {
      delete : "/e4/client/{client.name}/topic/{topic=**}"
    };
  }
  // Count the number of topics for a client
  rpc CountTopicsForClient(CountTopicsForClientRequest) returns (CountTopicsForClientResponse) {
    option (google.api.http) = {
      get : "/e4/client/{client.name}/topics/count"
    };
  }
  // Retrieve paginated topics for a client
  rpc GetTopicsForClient(GetTopicsForClientRequest) returns (GetTopicsForClientResponse) {
    option (google.api.http) = {
      get : "/e4/client/{client.name}/topics"
    };
  }
  // Count the number of clients for a topic
  rpc CountClientsForTopic(CountClientsForTopicRequest) returns (CountClientsForTopicResponse) {
    option (google.api.http) = {
      get : "/e4/topic/{topic=**}/clients/count"
    };
  }
  // Retrieve paginated clients for a topic
  rpc GetClientsForTopic(GetClientsForTopicRequest) returns (GetClientsForTopicResponse) {
    option (google.api.http) = {
      get : "/e4/topic/{topic=**}/clients"
    };
  }
  // Count the number of clients
  rpc CountClients(CountClientsRequest) returns (CountClientsResponse) {
    option (google.api.http) = {
      get : "/e4/clients/count"
    };
  }
  // Retrieve paginated clients
  rpc GetClients(GetClientsRequest) returns (GetClientsResponse) {
    option (google.api.http) = {
      get : "/e4/clients"
    };
  }

  // Count the number of topics
  rpc CountTopics(CountTopicsRequest) returns (CountTopicsResponse) {
    option (google.api.http) = {
      get : "/e4/topics/count"
    };
  }
  // Retrieve paginated topics
  rpc GetTopics(GetTopicsRequest) returns (GetTopicsResponse) {
    option (google.api.http) = {
      get : "/e4/topics"
    };
  }

  // Create a client-client link between on a target client
  rpc LinkClient(LinkClientRequest) returns (LinkClientResponse) {
    option (google.api.http) = {
      post: "/e4/client/{targetClient.name}/link/{sourceClient.name}"
    };
  }

  // Remove a client-client link on a target client
  rpc UnlinkClient(UnlinkClientRequest) returns (UnlinkClientResponse) {
    option (google.api.http) = {
      delete: "/e4/client/{targetClient.name}/unlink/{sourceClient.name}"
    };
  }

  // Count clients linked to the given client
  rpc CountLinkedClients(CountLinkedClientsRequest) returns (CountLinkedClientsResponse) {
    option (google.api.http) = {
      get: "/e4/client/{client.name}/link/count"
    };
  }

  // Retrieve clients linked to the given client
  rpc GetLinkedClients(GetLinkedClientsRequest) returns (GetLinkedClientsResponse) {
    option (google.api.http) = {
      get: "/e4/client/{client.name}/link"
    };
  }

  // Send a client pubkey to another client (pubkey mode only)
  rpc SendClientPubKey(SendClientPubKeyRequest) returns (SendClientPubKeyResponse) {
    option (google.api.http) = {
      post: "/e4/send-client-pubkey"
      body: "*"
    };
  }

  // Remove a client pubkey from another client (pubkey mode only)
  rpc RemoveClientPubKey(RemoveClientPubKeyRequest) returns (RemoveClientPubKeyResponse) {
    option (google.api.http) = {
      post: "/e4/remove-client-pubkey"
      body: "*"
    };
  }

  // Remove all pubkeys from a client
  rpc ResetClientPubKeys(ResetClientPubKeysRequest) returns (ResetClientPubKeysResponse) {
    option (google.api.http) = {
      post: "/e4/reset-client-pubkeys"
      body: "*"
    };
  }

  // Generate a new C2 key
  rpc NewC2Key(NewC2KeyRequest) returns (NewC2KeyResponse) {
    option (google.api.http) = {
      post: "/e4/new-c2-key"
      body: "*"
    };
  }

  // ProtectMessage returns base64 encoded data, representing the input data protected with the input topic key.
  rpc ProtectMessage(ProtectMessageRequest) returns (ProtectMessageResponse) {
    option (google.api.http) = {
      post: "/e4/protect-message"
      body: "*"
    };
  }

  // UnprotectMessage returns base64 encoded data, representing the input data unprotected with the input topic key.
  rpc UnprotectMessage(UnprotectMessageRequest) returns (UnprotectMessageResponse) {
    option (google.api.http) = {
      post: "/e4/unprotect-message"
      body: "*"
    };
  }

  // Provide a stream on C2 system events, grpc only
  rpc SubscribeToEventStream(SubscribeToEventStreamRequest) returns (stream Event) {}

  rpc HealthCheck(HealthCheckRequest) returns (HealthCheckResponse) {
    option (google.api.http) = {
      get: "/e4/health-check"
    };
  }

  // Returns the configured CryptoMode (symkey or pubkey) of the C2 instance
  rpc GetCryptoMode(GetCryptoModeRequest) returns (GetCryptoModeResponse) {
    option (google.api.http) = {
      get: "/e4/crypto-mode"
    };
  }
}

message Client {
  string name = 1;
}

message NewClientRequest {
  Client client = 1;
  bytes key = 2;
}
message NewClientResponse {}

message RemoveClientRequest {
  Client client = 1;
}
message RemoveClientResponse {}

message NewTopicClientRequest {
  Client client = 1;
  string topic = 2;
}
message NewTopicClientResponse {}

message RemoveTopicClientRequest {
  Client client = 1;
  string topic = 2;
}
message RemoveTopicClientResponse {}

message ResetClientRequest {
  Client client = 1;
}
message ResetClientResponse {}

message NewTopicRequest {
  string topic = 1;
}
message NewTopicResponse {}

message RemoveTopicRequest {
  string topic = 1;
}
message RemoveTopicResponse {}

message NewClientKeyRequest {
  Client client = 1;
}
message NewClientKeyResponse {}

message CountTopicsForClientRequest {
  Client client = 1;
}
message CountTopicsForClientResponse {
  int64 count = 1;
}

message GetTopicsForClientRequest {
  Client client = 1;
  int64 offset = 2;
  int64 count = 3;
}
message GetTopicsForClientResponse {
  repeated string topics = 1;
}

message CountClientsForTopicRequest {
  string topic = 1;
}
message CountClientsForTopicResponse {
  int64 count = 1;
}

message GetClientsForTopicRequest {
  string topic = 1;
  int64 offset = 2;
  int64 count = 3;
}
message GetClientsForTopicResponse {
  repeated Client clients = 1;
}

message CountClientsRequest {}
message CountClientsResponse {
  int64 count = 1;
}

message GetClientsRequest {
  int64 offset = 1;
  int64 count = 2;
}
message GetClientsResponse {
  repeated Client clients = 1;
}

message CountTopicsRequest {}
message CountTopicsResponse {
  int64 count = 1;
}

message GetTopicsRequest {
  int64 offset = 1;
  int64 count = 2;
}
message GetTopicsResponse {
  repeated string topics = 1;
}

message LinkClientRequest {
  Client sourceClient = 1;
  Client targetClient = 2;
}
message LinkClientResponse {}

message UnlinkClientRequest {
  Client sourceClient = 1;
  Client targetClient = 2;
}
message UnlinkClientResponse {}

message CountLinkedClientsRequest {
  Client client = 1;
}
message CountLinkedClientsResponse {
  int64 count = 1;
}
message GetLinkedClientsRequest {
  Client client = 1;
  int64 offset = 2;
  int64 count = 3;
}
message GetLinkedClientsResponse {
  repeated Client clients = 1;
}

message SendClientPubKeyRequest {
  Client sourceClient = 1;
  Client targetClient = 2;
}
message SendClientPubKeyResponse {}

message RemoveClientPubKeyRequest {
  Client sourceClient = 1;
  Client targetClient = 2;
}
message RemoveClientPubKeyResponse {}

message ResetClientPubKeysRequest {
  Client targetClient = 1;
}
message ResetClientPubKeysResponse {}

message NewC2KeyRequest {
  bool force = 1; // ensure this doesn't run by just poking at the endpoint
}
message NewC2KeyResponse {}

message ProtectMessageRequest {
  string topic = 1;
  bytes binaryData = 2;
}
message ProtectMessageResponse {
  string topic = 1;
  bytes protectedBinaryData = 2;
}

message UnprotectMessageRequest {
  string topic = 1;
  bytes protectedBinaryData = 2;
}
message UnprotectMessageResponse {
  string topic = 1;
  bytes binaryData = 2;
}

message SubscribeToEventStreamRequest {}

enum EventType {
  UNDEFINED = 0;
  CLIENT_SUBSCRIBED = 1;
  CLIENT_UNSUBSCRIBED = 2;
}

message Event {
  EventType type = 1;
  string source = 2;
  string target = 3;
  // Hold the time where event is sent
  google.protobuf.Timestamp timestamp = 4;
}

message HealthCheckRequest {}
message HealthCheckResponse {
  int64 Code  = 1;
  string Status  = 2;
}

enum CryptoMode {
  CRYPTOMODE_UNDEFINED = 0;
  CRYPTOMODE_SYMKEY = 1;
  CRYPTOMODE_PUBKEY = 2;
}

message GetCryptoModeRequest {}

message GetCryptoModeResponse {
  CryptoMode CryptoMode = 1;
}