SSL

This plugin provides native HTTP instrumentation for monitoring and metrics collection, including: response code, JSON response, HTTP last modified, SSL expiry, and metrics via `curl`.

Spoiled is a small tool to check SSL expiration dates

OpenURI ripped from 1.8.7's standard lib. Added option, :ssl_verify, which makes it possible to skip certificate verification.

an SSL connection library for redis

This plugin provides native SSL instrumentation for monitoring, including: hostname and chain verification, cert and crl expiry, and Qualys SSL Labs reporting

Originally created for tests that require SSL certs with passphrases

Connect to Redis via SSL sockets

slack-rtmapi2 is dumb: no EventMachine, no Celluloid, no Actor design pattern, no thread pool (thought, any of those would be trivial to add). It's a simple loop on top of a SSL socket with a websocket decoder. Minimal dependency. Works out of the box. Hackable. Composable. Oh, by the way, it implements very well the Slack API.

A gem that provides a simple and dirty HTTP client that handles get, post, and automatic SSL

MockServer enables easy mocking of any system you integrate with via HTTP or HTTPS with clients written in Java, JavaScript and Ruby and a simple REST API (as shown below). MockServer Proxy is a proxy that introspects all proxied traffic including encrypted SSL traffic and supports Port Forwarding, Web Proxying (i.e. HTTP proxy), HTTPS Tunneling Proxying (using HTTP CONNECT) and SOCKS Proxying (i.e. dynamic port forwarding). Both MockServer and the MockServer Proxy record all received requests so that it is possible to verify exactly what requests have been sent by the system under test.

A simple wrapper to Open ssl to easily encrypt/obfuscate data.

SSL Proxy for HTTP Thin servers

The **dropbox-api** is a Ruby gem for managing DropBox uploading, downloading and sharing DropBox files and folders. The main goals of building this gem are: 1. Simulate a **permanent access token**, since [Dropbox is moving to "short-term live access codes"](https://www.dropboxforum.com/t5/Discuss-Dropbox-Developer-API/Permanent-access-token/td-p/592644); 2. Manage DropBox as an elastic-storage providers for [our SaaS projects](https://github.com/leandrosardi/mysaas), allowing us to upload, download and share download links to files; 3. Backup and restore secret files of our projects that cannot be commited into the source code repository (E.g.: database passwords, SSL certificates, private keys).

Solves Ruby 1.9 SSL error

A Vagrant plugin that installs CA certificates onto the virtual machine. This is useful, for example, in the case where you are behind a corporate proxy server that injects its own self signed SSL certificates when you visit https sites.

A generic Fluentd output plugin to send records to HTTP / HTTPS endpoint, with SSL, Proxy, and Header implementation

Useful when implementing ssl without having to push cert into version control. Downloads ssl cert and key from remote location and stores them locally

Zurp allows your to quickly enable, disable, delete and create nginx virtualhosts, with templates for passenger virtualhosts (ruby, python, nodejs), php, laravel and ssl.

SSL requirement adds a declarative way of specifying that certain actions should only be allowed to run under SSL, and if they're accessed without it, they should be redirected.

Merb plugin that provides ssl_requirement from rails

seeing if I get an ssl error..

SSL Based separation of duties 4 rails

Common Messaging Layer [CML] is mostly useful for establishing a stable,secure communication channel using ZMQ sockets behind. Additonally, it uses open-ssl for secure channels. It linux kernel independent, can be run on any machine implementing between any entities starting from linux upstart jobs to python application services. Its fast and easy to integrate with any of your code.

SSL requirement adds a declarative way of specifying that certain actions should only be allowed to run under SSL, and if they're accessed without it, they should be redirected.

Ruby C Language Extension To Get SSL Certificate Information From URL

https://www.ssl.com/ssl-manager/

A generic Fluentd output plugin to send logs to an HTTP endpoint with SSL and Header option, extended from kawasakitoshiya@gmail.com's similarily named gem'

Wrap routes in a 'secured' block to only appear when on an SSL connection

encode OpenSSL::PKey to der/pem

SSL ThinClict

Official OmniAuth strategy for SSL.com

A simple gem checking for ssl expiry.

Package for creating self signed certificates for development purpose

certstash-cli manages the creation, storage, and retrieval of SSL keys and CRTs.

Sign and generate SSL certificates with ease

Brute force Cisco SSL VPN's that don't use 2-factor authentication

MiniHttp provides a clean, easy-to-use interface for making HTTP requests with automatic JSON handling, SSL support, and customizable timeouts.

Certgen is a command-line Ruby gem that helps users generate free SSL certificates from Let's Encrypt using DNS-01 verification. Ideal for users with manual or cPanel-based hosting environments. Supports wildcard domains and reusable account keys.

Automatically configure NGINX with SSL upon boot for Rails applications.

Utility gem with an added CLI for configuring NGINX with SSL.

# Quick Start The Owner API uses the JSON format, and must be accessed over a [secure connection](https://en.wikipedia.org/wiki/HTTPS). Let’s assume that the access token provided by your account manager is “TOKEN”. Here’s how to get the list of ids of all your invoices from the first week of August with a shell script: ```bash query="end_date=2018-08-08T00%3A00%3A00%2B00%3A00&start_date=2018-08-01T00%3A00%3A00%2B00%3A00" curl -i "https://api-eu.getaround.com/owner/v1/invoices?${query}" \ -H "Authorization: Bearer TOKEN" \ -H "Accept:application/json" \ -H "Content-Type:application/json" ``` And here’s how to get the invoice with the id 12345: ```bash curl -i "https://api-eu.getaround.com/owner/v1/invoices/12345" \ -H "Authorization: Bearer TOKEN" \ -H "Accept: application/json" \ -H "Content-Type: application/json"" ``` See the [endpoints section](#tag/Invoices) of this guide for details about the response format. Dates in request params should follow the ISO 8601 standard. # Authentication All requests must be authenticated with a [bearer token header](https://tools.ietf.org/html/rfc6750#section-2.1). You token will be sent to you by your account manager. Unauthenticated requests will return a 401 status. # Pagination The page number and the number of items per page can be set with the “page” and “per_page” params. For example, this request will return the second page of invoices, and 50 invoices per page: `https://api-eu.getaround.com/owner/v1/invoices?page=2&per_page=50` Both of these params are optional. The default page size is 30 items. The Getaround Owner API follows the [RFC 8288 convention](https://datatracker.ietf.org/doc/html/rfc8288) of using the `Link` header to provide the `next` page URL. Please don't build the pagination URLs yourself. The `next` page will be missing when you are requesting the last available page. Here's an example response header from requesting the second page of invoices `https://api-eu.getaround.com/owner/v1/invoices?page=2&per_page=50` ``` Link: <https://api-eu.getaround.com/owner/v1/invoices?page=3&per_page=50>; rel="next" ``` # Throttling policy and Date range limitation We have throttling policy that prevents you to perform more than 100 requests per min from the same IP. Also, there is a limitation on the size of the range of dates given in params in some requests. All requests that need start_date and end_date, do not accept a range bigger than 30 days. # Webhooks Getaround can send webhook events that notify your application when certain events happen on your account. This is especially useful to follow the lifecycle of rentals, tracking for example bookings or cancellations. ### Setup To set up an endpoint, you need to define a route on your server for receiving events, and then <a href="mailto:owner-api@getaround.com">ask Getaround</a> to add this URL to your account. To acknowledge receipt of a event, your endpoint must: - Return a `2xx` HTTP status code. - Be a secure `https` endpoint with a valid SSL certificate. ### Testing Once Getaround has set up the endpoint, and it is properly configured as described above, a test `ping` event can be sent by clicking the button below: <form action="/docs/api/owner/fire_ping_webhook" method="post"><input type="submit" value="Send Ping Event"></form> You should receive the following JSON payload: ```json { "data": { "ping": "pong" }, "type": "ping", "occurred_at": "2019-04-18T08:30:05Z" } ``` ### Retries Webhook deliveries will be attempted for up to three days with an exponential back off. After that point the delivery will be abandoned. ### Verifying Signatures Getaround will also provide you with a secret token, which is used to create a hash signature with each payload. This hash signature is passed along with each request in the headers as `X-Drivy-Signature`. Suppose you have a basic server listening to webhooks that looks like this: ```ruby require 'sinatra' require 'json' post '/payload' do push = JSON.parse(params[:payload]) "I got some JSON: #{push.inspect}" end ``` The goal is to compute a hash using your secret token, and ensure that the hash from Getaround matches. Getaround uses an HMAC hexdigest to compute the hash, so you could change your server to look a little like this: ```ruby post '/payload' do request.body.rewind payload_body = request.body.read verify_signature(payload_body) push = JSON.parse(params[:payload]) "I got some JSON: #{push.inspect}" end def verify_signature(payload_body) signature = 'sha1=' + OpenSSL::HMAC.hexdigest(OpenSSL::Digest.new('sha1'), ENV['SECRET_TOKEN'], payload_body) return halt 500, "Signatures didn't match!" unless Rack::Utils.secure_compare(signature, request.env['HTTP_X_DRIVY_SIGNATURE']) end ``` Obviously, your language and server implementations may differ from this code. There are a couple of important things to point out, however: No matter which implementation you use, the hash signature starts with `sha1=`, using the key of your secret token and your payload body. Using a plain `==` operator is not advised. A method like secure_compare performs a "constant time" string comparison, which renders it safe from certain timing attacks against regular equality operators. ### Best Practices - **Acknowledge events immediately**. If your webhook script performs complex logic, or makes network calls, it’s possible that the script would time out before Getaround sees its complete execution. Ideally, your webhook handler code (acknowledging receipt of an event by returning a `2xx` status code) is separate of any other logic you do for that event. - **Handle duplicate events**. Webhook endpoints might occasionally receive the same event more than once. We advise you to guard against duplicated event receipts by making your event processing idempotent. One way of doing this is logging the events you’ve processed, and then not processing already-logged events. - **Do not expect events in order**. Getaround does not guarantee delivery of events in the order in which they are generated. Your endpoint should therefore handle this accordingly. We do provide an `occurred_at` timestamp for each event, though, to help reconcile ordering.

Tool to pull windows certs and inject them into your ruby's openssl store

fluentd plugin to check ssl endpoint

A Compression/Encyption All in one framework. No this is not sequential C/E but rather fully intergrated C/E built entirely from Ruby. Forking from both the LZW and Twofish source code and meshing the two into seamless platform for C/E/FT. RbShard introduces a brand new file extension (.rbs). Currently the file extension (.rbs) and its graphic (A cutout of the middle section of a ruby outlined in red and filled with black. on a black towhite center spectrum filepage) are still under development. RbShard as in future release v. 0.0.2 will only support the creation of .rbs. Development of a framework is currently UnD to support file transfer with on a secure SSL channel using a QEKM (Quantum Electronic Key Mangement) driver and a fully dedicated server. Currently this technology is considered 'Bleeding Edge'. and entirely proprietary in nature as this Gem is updated any feedback or assistance is more than appreciated.

Using the Certificate Manager Service, you can conveniently provision and manage SSL certificates with IONOS services and your internal connected resources. For the [Application Load Balancer](https://api.ionos.com/docs/cloud/v6/#Application-Load-Balancers-get-datacenters-datacenterId-applicationloadbalancers), you usually need a certificate to encrypt your HTTPS traffic. The service provides the basic functions of uploading and deleting your certificates for this purpose.

# Payfast Payfast is a Ruby gem that simplifies the process of integrating the PayFast payment gateway into your Ruby on Rails application. It provides a generator that helps scaffold the necessary configuration, routes, models, and controllers required to integrate PayFast seamlessly. ## Demo  ## Installation Add this line to your application's Gemfile: ```bash bundle add payfast ``` ## Usage ```bash rails generate payfast:install ``` ## This generator will perform the following actions: insert config/routes.rb create app/controllers/carts_controller.rb create app/views/carts/index.html.erb create app/views/carts/make_payment.html.erb create app/helpers/carts_helper.rb create db/migrate/20230824105530_create_carts.rb create config/payfast.yml create app/models/cart.rb insert app/views/layouts/application.html.erb insert config/environments/development.rb ## Additional configuration Setup payfast credentials for your environment rails EDITOR="code --wait" bin/rails credentials:edit This will allow you to securely edit and store your credentials. once you save and exit the file, the credentials will be encrypted and can only be accessed withe rails master key. payfast: merchant_id: {your_merchant_id} merchant_key: {your_merchant_key} passphrase: {{your_passphrase}} ## Update your `payfast.yml` config file - setup the credentials to be use by the rails app - uncomment `Rails.application.credentials.payfast.merchant_id ` and wrap it in erb tags as instructed in the comments. ## Templates Update the `make_payment.html.erb` as instructed in the file. it should look like so: ```js <script> // set the uuid to uuid = @cart.payment_uid. surround @carts.payment_uid with erb tags const uuid = `<%= @cart.payment_uuid %>` window.payfast_do_onsite_payment({uuid}, function (result) { if (result === true) { // redirect success_path(@cart) window.location.href = `<%= success_cart_path(@cart) %>` } else { // Redirect to failure_path(@cart) window.location.href = `<%= failure_cart_path(@cart) %>` } }); </script> ``` ## Testing - payfast api allows only SSL communication from your server. inorder to test locally. you will have to use a tunneling service that allows you to expose your local development server to the internet. your rails development config has was modified by the generator to allow ngrok hosts to hit your rails server ```ruby config.hosts << /[a-z0-9-]+\.ngrok-free\.app/ ``` ## Contributing Thank you for considering contributing to our project! We welcome contributions from the community to help improve this project and make it better for everyone. ### Issues If you encounter any issues or bugs while using our project, please [open a new issue](https://github.com/mactunechy/payfast/issues) on GitHub. Please make sure to include detailed information about the problem, steps to reproduce it, and the environment in which you encountered it. ### Pull Requests We encourage pull requests from the community! If you have an improvement or new feature you'd like to contribute, please follow these steps: 1. Fork the repository and create a new branch for your feature or bug fix. 2. Make your changes and write tests to cover any new functionality. 3. Ensure that the existing tests pass and write additional tests for any bug fixes. 4. Commit your changes and push the new branch to your forked repository. 5. Submit a pull request to our main repository, including a detailed description of the changes you made and any relevant information. We will review your pull request as soon as possible and provide feedback if needed. We value your contributions and will work with you to ensure your changes are integrated smoothly. d Your contributions are essential to the success of this project, and we are grateful for your help in making it better for everyone. If you have any questions or need further assistance, feel free to reach out to us. Happy coding!