Webhooks

const crypto = require("crypto");

const signedContent = `${webhook_id}.${webhook_timestamp}.${body}`;
const SECRET = "5WbX5kEWLlfzsGNjH64I8lOOqUB6e8FH";

// base64 decode the secret before use
const secretBytes = new Buffer(SECRET, "base64");
const signature = crypto
  .createHmac("sha256", secretBytes)
  .update(signedContent)
  .digest("base64");

import hmac
import base64

signedContent = f"{webhook_id}.{webhook_timestamp}.{body}"
SECRET = "5WbX5kEWLlfzsGNjH64I8lOOqUB6e8FH"

# base64 decode the secret before use
secretBytes = base64.b64decode(SECRET)
signature = base64.b64encode(
    hmac.new(
        secretBytes,
        signedContent.encode(),
        'sha256'
    ).digest()
).decode()

import javax.crypto.Mac;
import javax.crypto.spec.SecretKeySpec;
import java.nio.charset.StandardCharsets;
import java.util.Base64;

public class Main {
    public static void main(String[] args) throws Exception {
        String signedContent = webhook_id + "." + webhook_timestamp + "." + body;
        String SECRET = "5WbX5kEWLlfzsGNjH64I8lOOqUB6e8FH";

        // Need to base64 decode the secret
        byte[] secretBytes = Base64.getDecoder().decode(SECRET);

        Mac sha256_HMAC = Mac.getInstance("HmacSHA256");
        SecretKeySpec secret_key = new SecretKeySpec(secretBytes, "HmacSHA256");
        sha256_HMAC.init(secret_key);

        byte[] rawHmac = sha256_HMAC.doFinal(signedContent.getBytes(StandardCharsets.UTF_8));

        // base64 encode the result
        String signature = Base64.getEncoder().encodeToString(rawHmac);
        System.out.println(signature);
    }
}

import Finch from '@tryfinch/finch-api';
...

app.use('/webhooks/finch', bodyParser.text({ type: '_/_' }), function (req, res) {
const finch = new Finch();
const payload = finch.webhooks.unwrap(req.body, req.headers, process.env['FINCH_WEBHOOK_SECRET']); // env var used by default; explicit here.
console.log(payload);
res.json({ ok: true });
});

from finch import Finch
...

@app.post('/webhooks/finch')
async def handler(request: Request):
    body = await request.body() # raw JSON string sent from the server
    secret = os.environ['FINCH_WEBHOOK_SECRET']  # env var used by default; explicit here.
    client = Finch()
    payload = client.webhooks.unwrap(body, request.headers, secret)
    print(payload)

    return {'ok': True}

import com.tryfinch.api.client.FinchClient;
import com.tryfinch.api.client.okhttp.FinchOkHttpClient;
...

@RestController
public class WebhookController {

    @PostMapping("/webhooks/finch")
    public HttpStatus handleWebhook(HttpServletRequest request, @RequestBody String payload) {
        try {
            FinchClient finch = FinchOkHttpClient.builder().webhookSecret("your-secret").build();

            // Implement this to get headers from request as a ListMultimap
            ListMultimap<String, String> headers = this.getHeadersFromRequest(request);

            // Validate signature
            finch.webhooks().verifySignature(payload, headers, null);

            // Implement this to handle webhook payload
            this.handleWebhookPayload(payload);
        } catch (Exception e) {
            // Handle exception
            return HttpStatus.INTERNAL_SERVER_ERROR;
        }

        return HttpStatus.OK;
    }
}

import com.tryfinch.api.client.FinchClient
import com.tryfinch.api.client.okhttp.FinchOkHttpClient
...

@RestController
class WebhookController {

  @PostMapping("/webhooks/finch")
  fun handleWebhook(request: HttpServletRequest, @RequestBody payload: String): HttpStatus {
      try {
          val finch = FinchOkHttpClient.builder().webhookSecret("your-secret").build()

          // Implement this function to get headers from request as a ListMultimap
          val headers = getHeadersFromRequest(request)

          // Validate signature
          finch.webhooks().verifySignature(payload, headers, null)

          // Implement this to handle webhook payload
          handleWebhookPayload(payload)
      } catch (e: Exception) {
          // Handle exception
          return HttpStatus.INTERNAL_SERVER_ERROR
      }

      return HttpStatus.OK
  }
}

import (
  finchgo "github.com/Finch-API/finch-api-go"
  ...
)


func webhookHandler(w http.ResponseWriter, r *http.Request) {
  header := r.Header
  secret :=  os.Getenv("FINCH_WEBHOOK_SECRET")
  now := time.Now()
  b, err := ioutil.ReadAll(r.Body)
  if err != nil {
    panic(err)
  }

  client := finchgo.NewClient()
  err = client.Webhooks.VerifySignature([]byte(b), header, secret, now)
  if err != nil {
    fmt.Println("Error with signature")
    os.Exit(1)
  }
    fmt.Fprintf(w, "Response to finch webhook")
}

func TestAppServer() {
  http.HandleFunc("/webhooks/finch", webhookHandler)

  log.Fatal(http.ListenAndServe(":8081", nil))
}