static private async Task api(string[] args)
{
UserCognitoCredentials credentials = getSavedCredentials();
if (credentials == null)
{
String password = GetPassword();
credentials = getCognitoCredentials(args[0], password).Result;
saveCredentials(credentials);
}
var signer = new AWS4RequestSigner(credentials.getAccessKey(), credentials.getSecretKey());
var request = new HttpRequestMessage {
Method = HttpMethod.Get,
RequestUri = new Uri("https://ats.api.alexa.com/api?Action=TopSites&Count=5&CountryCode=" + args[2] + "&ResponseGroup=Country")
};
request.Headers.Add("x-api-key", args[1]);
request.Headers.Add("x-amz-security-token", credentials.getSessionToken());
request = await signer.Sign(request, "execute-api", "us-east-1");
var client = new HttpClient();
var response = await client.SendAsync(request);
var responseStr = await response.Content.ReadAsStringAsync();
Console.WriteLine(responseStr);
}
public DigitalOceanBucketClient(HttpClient client, string accessKeyID, string accessKeySecret, string region)
{
var signer = new AWS4RequestSigner(accessKeyID, accessKeySecret);
_client = new DigitalOceanHttpClient(client, signer, region);
_region = region;
}
public Function()
{
signer = new AWS4RequestSigner(ACCESS_KEY, SECRET_KEY);
var config = new AmazonDynamoDBConfig {
RegionEndpoint = RegionEndpoint.EUWest1
};
var client = new AmazonDynamoDBClient(config);
table = Table.LoadTable(client, Environment.GetEnvironmentVariable("CONNECTION_ID_TABLE"));
}
static private async Task api(string[] args)
{
var signer = new AWS4RequestSigner(args[0], args[1]);
var request = new HttpRequestMessage {
Method = HttpMethod.Get,
RequestUri = new Uri("https://awis.us-west-1.amazonaws.com/api?Action=urlInfo&ResponseGroup=Rank&Url=" + args[2])
};
request = await signer.Sign(request, "awis", "us-west-1");
var client = new HttpClient();
var response = await client.SendAsync(request);
var responseStr = await response.Content.ReadAsStringAsync();
Console.WriteLine(responseStr);
}
public async Task <string> Get()
{
var endpointUri = _configuration["AWS:urlAPIGw"];
var signer = new AWS4RequestSigner(_configuration["AWS:Key"], _configuration["AWS:Secret"]);
var request = new HttpRequestMessage {
Method = HttpMethod.Get,
RequestUri = new Uri(endpointUri)
};
request = await signer.Sign(request, _configuration["AWS:Service"], _configuration["AWS:Region"]);
var client = new HttpClient();
var response = await client.SendAsync(request);
var responseStr = await response.Content.ReadAsStringAsync();
return(responseStr);
}
public async Task FunctionHandler(Request request, ILambdaContext context)
{
try
{
var accessKey = Environment.GetEnvironmentVariable("ACCESS_KEY");
var secretKey = Environment.GetEnvironmentVariable("SECRET_KEY");
var signer = new AWS4RequestSigner(accessKey, secretKey);
var repositoryUrl = $"{request.Endpoint}/_snapshot/{request.RepositoryName}";
var service = "es";
await RegisterS3Repository(request, context, signer, repositoryUrl, service);
await CreateSnapshot(request, context, signer, repositoryUrl, service);
}
catch (Exception ex)
{
context.Logger.LogLine($"Error performing backup: {ex.Message}");
throw;
}
}
public async Task <string> Post(InputModel input)
{
var endpointUri = _configuration["AWS:urlSocketAPI"] + input.connection_id;
var signer = new AWS4RequestSigner(_configuration["AWS:Key"], _configuration["AWS:Secret"]);
var request = new HttpRequestMessage {
Method = HttpMethod.Post,
RequestUri = new Uri(endpointUri),
Content = new StringContent(input.message)
};
request = await signer.Sign(request, _configuration["AWS:Service"], _configuration["AWS:Region"]);
var client = new HttpClient();
var response = await client.SendAsync(request);
var responseStr = await response.Content.ReadAsStringAsync();
return(responseStr);
}
public async Task <HttpResponse> FunctionHandler(APIGatewayProxyRequest input, ILambdaContext context)
{
var message = JsonConvert.DeserializeObject <TmpMessage>(input.Body);
var table = Table.LoadTable(client, "ConnectionIds");
var scanFilter = new ScanFilter();
var search = table.Scan(scanFilter);
var remaining = await search.GetRemainingAsync();
var httpClient = new HttpClient();
// Function no longer in use, therefore no up-to-date keys
var signer = new AWS4RequestSigner("AccessKey", "SecretKey");
foreach (var doc in remaining)
{
var connectionId = doc["ConnectionId"];
var endpoint =
$"https://{input.RequestContext.DomainName}/{input.RequestContext.Stage}/@connections/{connectionId}";
var request = new HttpRequestMessage
{
Method = HttpMethod.Post,
RequestUri = new Uri(endpoint),
Content = new StringContent(message.Message)
};
request = await signer.Sign(request, "execute-api", "eu-west-1");
var response = await httpClient.SendAsync(request);
Console.WriteLine(await response.Content.ReadAsStringAsync());
}
return(new HttpResponse
{
statusCode = HttpStatusCode.OK
});
}
private static async Task <HttpResponseMessage> CallWebservice(HttpMethod method, Uri uri, byte[] content = null)
{
var signer = new AWS4RequestSigner(keyId, secretAccessKey);
var request = new HttpRequestMessage
{
Method = method,
RequestUri = uri
};
if (content != null)
{
request.Content = new ByteArrayContent(content);
string sha256Hash = Hash(content);
request.Headers.Add("x-amz-content-sha256", sha256Hash);
}
request = await signer.Sign(request, service, region);
var client = new HttpClient();
var response = await client.SendAsync(request);
return(response);
}
static async Task <HttpRequestMessage> GetSignedRequest(HttpRequestMessage request)
{
var signer = new AWS4RequestSigner(Env.Var.ESAwsAccessKey, Env.Var.ESAwsSecretAccessKey);
return(await signer.Sign(request, "es", Env.Var.ESAwsRegion));
}
private static async Task RegisterS3Repository(Request request, ILambdaContext context, AWS4RequestSigner signer, string repositoryUrl, string service)
{
context.Logger.LogLine($"Register ElasticSearch Repository: {request.RepositoryName}");
var requestBody = new
{
type = "s3",
settings = new
{
bucket = request.S3Bucket,
region = request.Region,
role_arn = request.RoleArn
}
};
string requestBodyString = System.Text.Json.JsonSerializer.Serialize(requestBody);
var content = new StringContent(requestBodyString, Encoding.UTF8, "application/json");
var httpRequestRepository = new HttpRequestMessage
{
Method = HttpMethod.Put,
RequestUri = new Uri(repositoryUrl),
Content = content
};
httpRequestRepository = await signer.Sign(httpRequestRepository, service, request.Region);
var client = new HttpClient();
var responseRepository = await client.SendAsync(httpRequestRepository);
if (!responseRepository.IsSuccessStatusCode)
{
throw new Exception($"Error registering repository {request.RepositoryName}.\n" +
$"Error code: {responseRepository.StatusCode}.\n" +
$"Content: {await responseRepository.Content.ReadAsStringAsync()}");
}
context.Logger.LogLine($"ElasticSearch Repository {request.RepositoryName} successfully registered");
}
private static async Task CreateSnapshot(Request request, ILambdaContext context, AWS4RequestSigner signer, string repositoryUrl, string service)
{
var snapshotName = DateTime.Now.ToString("dd-MM-yyyy-h-mm-ss").ToLower();
context.Logger.LogLine($"Create ElasticSearch Image: {repositoryUrl}/{snapshotName}");
var httpRequestSnapshot = new HttpRequestMessage
{
Method = HttpMethod.Put,
RequestUri = new Uri($"{repositoryUrl}/{snapshotName}"),
Content = null
};
httpRequestSnapshot = await signer.Sign(httpRequestSnapshot, service, request.Region);
var client = new HttpClient();
var responseSnapshot = await client.SendAsync(httpRequestSnapshot);
if (!responseSnapshot.IsSuccessStatusCode)
{
throw new Exception($"Error creating snapshot {snapshotName}.\n" +
$"Error code: {responseSnapshot.StatusCode}.\n" +
$"Content: {await responseSnapshot.Content.ReadAsStringAsync()}");
}
context.Logger.LogLine($"ElasticSearch snapshot {snapshotName} successfully registered");
}
private static async Task <bool> PutLogData
(
HttpClient client,
string logName,
string logData,
string profile,
TelemetryConfiguration telemetryConfiguration
)
{
const string PathTemplate = "/put-log-data";
try
{
var chain = new CredentialProfileStoreChain();
AWSCredentials awsCredentials;
var profileName = profile;
var region = telemetryConfiguration.Region;
if (chain.TryGetAWSCredentials(profileName, out awsCredentials))
{
var signer = new AWS4RequestSigner
(
awsCredentials.GetCredentials().AccessKey,
awsCredentials.GetCredentials().SecretKey
);
dynamic requestMetadata = new JObject();
requestMetadata.version = "1.0";
requestMetadata.service = telemetryConfiguration.ServiceName;
requestMetadata.token = "12345678";
requestMetadata.description = telemetryConfiguration.Description;
dynamic log = new JObject();
log.timestamp = DateTime.Now.ToString();
log.logName = logName;
var logDataInBytes = System.Text.Encoding.UTF8.GetBytes(logData);
log.logData = System.Convert.ToBase64String(logDataInBytes);
dynamic body = new JObject();
body.requestMetadata = requestMetadata;
body.log = log;
var requestContent = new StringContent(body.ToString(Formatting.None), Encoding.UTF8, "application/json");
var requestUri = new Uri(String.Join("", telemetryConfiguration.InvokeUrl, PathTemplate));
var request = new HttpRequestMessage
{
Method = HttpMethod.Post,
RequestUri = requestUri,
Content = requestContent
};
request = await signer.Sign(request, "execute-api", region);
var response = await client.SendAsync(request);
if (!response.IsSuccessStatusCode)
{
Log.Logger.Error("Http response faild with status code: " + response.StatusCode.ToString());
}
return(response.IsSuccessStatusCode);
}
Log.Logger.Error("Invalid Credentials.");
return(false);
}
catch (Exception ex)
{
Log.Logger.Error(ex.Message);
return(false);
}
}
public DigitalOceanHttpClient(HttpClient client, AWS4RequestSigner signer, string region)
{
_client = client;
_signer = signer;
_region = region;
}
async Task <HttpRequestMessage> GetSignedRequest(HttpRequestMessage request)
{
var signer = new AWS4RequestSigner(env.AWS_ACCESSKEY, env.AWS_SECRETACCESSKEY);
return(await signer.Sign(request, "execute-api", env.AWS_REGION));
}
async Task <HttpRequestMessage> GetSignedRequest(HttpRequestMessage request)
{
var signer = new AWS4RequestSigner(env.AWS_ACCESS_KEY_ID, env.AWS_SECRET_ACCESS_KEY);
return(await signer.Sign(request, "es", env.AWS_DEFAULT_REGION));
}
private async Task <HttpRequestMessage> GetSignedRequest(HttpRequestMessage request)
{
var signer = new AWS4RequestSigner(_searchConfiguration.AWSESAccessKey, _searchConfiguration.AWSESSecretKey);
return(await signer.Sign(request, "es", _searchConfiguration.AWSESRegion));
}
