Blue Cross Blue Shield of Illinois allegedly failed to protect the information of current and former members that was exposed in a June data breach, a proposed federal class action said.

Blue Cross Blue Shield of Illinois Sued Over June Data Breach

Space Force is looking at broadening national security launches late in this decade to a wider ... such as the New Glenn rockets being designed by Jeff Bezos’ Blue Origin, and specialized small-satellite launch startups to compete for missions.

Space Force picks Centennial-based ULA for slate of national security launches

The phenomenon, in which the second full moon of the calendar month reaches full moon at its closest point to Earth, is set to arrive Wednesday night.

How to see the big, gleaming super blue moon in the US on Wednesday night

To qualify, Blue Origin must have a credible plan to achieve certification ... Elon Musk’s SpaceX had to sue the Air Force to break ULA’s monopoly on national security launch and has since become a dominant provider of reusable launch for the Space ...

Op-ed | Space Force launch strategy a step in the right direction

MEMPHIS, Tenn., Nov. 1, 2023 /CNW/ - Ting Internet, a division of Tucows (NASDAQ: TCX) (TSX: TC), announced that it has been selected to provide fiber internet service to Memphis residents, businesses, and institutions in partnership with Blue Suede Networks.

TING SELECTED AS BLUE SUEDE NETWORKS' FIBER INTERNET SERVICE PROVIDER

As Europe witnesses a sharp increase in antisemitic incidents, the EU says ”it is in touch with member states and with Jewish communities in particular with regards to security concerns.” Blue stars of David painted on several houses in Paris.

EU: ‘Protecting Jewish life in Europe, a key component of our strategy to combat antisemitism’

Nasdaq: KSCP] (“Knightscope” or the “Company”), a leading developer of autonomous security robots and blue light emergency communication systems, today announces the expansion of an existing retail client and a new contract with a university in Alaska.

Retailer Expands and University Upgrades with Knightscope Technologies

The company had posted a net profit of Rs 42.64 crore a year ago, according to a regulatory filing from Blue Star. Its revenue from operations during the quarter under review rose 19.47 per cent to Rs 1,

Blue Star Q2 results: Net profit jumps 66% to Rs 70.8 crore

This Blue Ridge Re catastrophe bond sees another new first-time sponsor entering the cat bond market, as the North Carolina Farm Bureau seeks reinsurance from the capital markets for its underwriting entities. A new Bermuda based vehicle named Blue Ridge ...

Blue Ridge Re Ltd. (Series 2023-1)

POTTSTOWN — VideoRay, the producer of the Mission Specialist Defender underwater robot, has acquired Blue Ring Imaging, a St. Petersburg, Fla.-based innovator in 3D visualization, multi-view perception, and simulation for unmanned systems.

VideoRay of Pottstown acquires Blue Ring Imaging’s AI capabilities

Blue Security

bluesecurity

Introducing the InfoSec colour wheel — blending developers with red and blue security teams.

Presentamos la rueda de colores de InfoSec — que combina desarrolladores con equipos de seguridad rojos y azules.

Open API specifications are increasingly becoming a popular way to describe and document APIs. The benefits of using an Open API specification include the ability to generate documentation and specifications from the client code, and the fact that many API management support the Open API specification. tools In this article, we'll take a look at what an Open API specification is, and how you can use it to document your APIs. Introduction to OpenAPI Specification OpenAPI Specification (formerly Swagger Specification) is an API description format for REST APIs. An OpenAPI file allows you to describe your entire API, including: • The available endpoints (URLs) and methods (e.g. GET, POST, etc.) • The input and output for each endpoint • The authentication methods In addition to documenting the API, an Open API specification can also be used to generate documentation and client code. Many API management tools support the Open API specification, which makes it easy to create and maintain APIs. Some of the main components of OAS are path, parameters, responses, and security. Each of them is a JSON object that holds properties and an array. The field contains high-level information about the API, version of the document, license, contact, and description. info The server field describes the root endpoint for the API, later used to construct the entire URL from the path. "info": {
        "description": "This is a sample server Petstore server.  You can find out more about Swagger at [http://swagger.io](http://swagger.io) or on [irc.freenode.net, #swagger](http://swagger.io/irc/).  For this sample, you can use the api key `special-key` to test the authorization filters.",
        "version": "1.0.6",
        "title": "Swagger Petstore",
        "termsOfService": "http://swagger.io/terms/",
        "contact": {
            "email": "apiteam@swagger.io"
        },
        "license": {
            "name": "Apache 2.0",
            "url": "http://www.apache.org/licenses/LICENSE-2.0.html"
        }
    } objects hold individual endpoints and their operations. Then the path is appended to the URL from the Server Object in order to reconstruct the full URL. Path For example, here is the POST request for path. /pet "/pet": {
            "post": {
                "tags": ["pet"],
                "summary": "Add a new pet to the store",
                "description": "",
                "operationId": "addPet",
                "consumes": ["application/json", "application/xml"],
                "produces": ["application/json", "application/xml"],
                "parameters": [{
                    "in": "body",
                    "name": "body",
                    "description": "Pet object that needs to be added to the store",
                    "required": true,
                    "schema": {
                        "$ref": "#/definitions/Pet"
                    }
                }],
                "responses": {
                    "405": {
                        "description": "Invalid input"
                    }
                },
                "security": [{
                    "petstore_auth": ["write:pets", "read:pets"]
                }]
            }, The OAS can be written in JSON format or YAML. Explain this JSON code from the official website. swagger is the endpoint /pets POST is the method Parameters list the parameters for the specific endpoint schema is a reference to another part of the specification that adds additional information about the POST request $ref 405 is the status code security is a list of permissions for the endpoint Many more pathways, as well as extra HTTP method operations for the same path, would most likely be defined in an OpenAPI specification. Next, the OpenAPI file describes the object. Components Object allows for the definition of metadata in the API. The metadata can then be reused across the API, making the API definition more concise. components Components Object acts as a container for all the schemas, responses, parameters, examples, and security schemes that your API uses. "components": {
    "schemas": {
      "overviewSegment": {
        "type": "object",
        "properties": {
          "success": {
            "type": "boolean",
            "example": true
          },
          "message": {
            "type": "string",
            "example": "Success View Segment"
          },
          "code": {
            "type": "string",
            "example": "200"
          },
          "data": {
            "$ref": "#/components/schemas/overviewSegment_data"
          }
        }
      } OpenAPI vs. Swagger OpenAPI and Swagger are two popular frameworks for defining and documenting APIs. Both are open-source projects and are widely used in the API community. Swagger started as an open-source project in 2011. It was acquired by SmartBear in 2015 and renamed OpenAPI Specification. OpenAPI Specification is now managed by the OpenAPI Initiative, which is hosted by the Linux Foundation. OpenAPI Specification (formerly Swagger Specification) is an API description format for REST APIs. An OpenAPI file allows you to describe your entire API, including: Available endpoint(s) and methods (e.g. GET, POST, etc.) The inputs and outputs for each endpoint The data types used Authentication methods Swagger is a set of open-source ton this environment the response differs from our website, maybe because we use the 12.1.5 version ( I also notice a new commit on the , maybe this is the reason). image.tsx During the new POC, you can see that the "d” parameter does not appear but I added it manually (URL encoded). Check out the new environment . here You can also view the new POC . here ols to use OpenAPI Specification to help you develop, document, and consume REST APIs. Swagger tools include: A web-based editor where you can write OpenAPI specs. Swagger Editor: A library that generates code (e.g. client SDKs, server stubs) from OpenAPI specs. Swagger Codegen: A web-based user interface that shows the documentation for an OpenAPI-defined API. Swagger UI: If you're just getting started with API development, we recommend using OpenAPI Specification. It's a great way to define and document your APIs. Once you're comfortable with OpenAPI Specification, you can start using Swagger tools to speed up your development process. OpenAPI Tools The ability to use the vast tool ecosystem that surrounds OpenAPI is a significant advantage. Many open-source and commercial tools assist API developers in developing, testing, documenting, and generating support code for their API. I've selected some of the most popular OpenAPI tools in a few key areas below. Since the rise of cloud computing about a decade ago, there has been an explosion of accessible technology. Developers are working hard to make things better, cooler, or slicker. It's difficult to keep track of tools as they change and others arise. In addition, because adopting new tools takes time, it becomes important to vet new tools for usage. It is no different in the API design environment. 🧪 Testing:Postman, Citrus, APIFortress, Postwoman, Everest. ** 🐞**Validation: OpenAPILint, Spectral, . CherryBomb 🧰 Editors:SwaggerHub, Visual Studio Code extension, KaiZen OpenAPI Editor, Stoplight, Insomnia Designer, Optic, and Curio. ** 📄**Documentation: Swagger UI, Widdershins, and openapi-viewer. ** ♾️**Code Generation: OpenAPI-generator, swagger-node-codegenGoogle Gnostic, and Gen. Furthermore, because adopting new tools takes time, evaluating new technologies for application is crucial. Consider an all-in-one  online tool that validates, tests your specs, develops a thorough real-time endpoint map, and walks you through the process using a params table. Wouldn't it be cool? I want to introduce  BLST’s solution for API development which is very much a game-changer. We just released it today for the first time! Visit , upload your OpenAPI file, and check out the results. blstsecurity.com Give us a star on . Also published . GitHub here

A Comprehensive Guide to OpenAPI Specification

The Rust community constantly discusses error handling. In this article, I will try to explain what it is, why, and how we should use it. Purpose of Error Handling Error handling is a process that helps to identify, debug, and resolve errors that occur during the execution of a program. It helps to ensure the smooth functioning of the program by preventing errors from occurring and allows the program to continue running in an optimal state. Error handling also allows users to be informed of any problems that may arise and take corrective action to prevent the errors from happening again in the future. What is a Result? A result is a built-in in the Rust standard library. It has two variants Ok(T) and Err(E). enum Result should be used as a return type for a function that can encounter error situations. The Ok value is return in case of success or an Err value in case of an error. Implementation of Result in a function. What is Error Handling Sometimes we use functions that can fail, for example when we call an endpoint from an API or search for a file. These types of functions can encounter errors (in our case the API is not reachable or the file does not exist). There are similar scenarios where we use Error Handling. Explained Step by Step A Result is the result of the read username from the file function. It follows that the function's returned value will either be an Ok that contains a String or an Err that contains an instance of io::Error. There is a call to "File::open" inside of read username from the file, which returns a Result type. It can return an Ok It can return an Err Then the code calls a match to check the result of the function and returns the value inside the ‘ok’ in the case the function was successful otherwise it returns the Error value. In the second function read_to_string, the same principle is applied, but in this case, we did not use the keyword ‘return’ as you can see, and we finally return either an OK or an Err. So you may ask: Do I have to write these Match blocks for every result type? Don’t Fret! There’s a shortcut! What is the Question Mark- Propagation Error? According to the book: rust lang The question mark operator (?) unwraps valid values or returns erroneous values, propagating them to the calling function. It is a unary postfix operator that can only be applied to the types Result and Option. Let's explain it. Question mark (?) in Rust is used to indicate a Result type. It is used to return an error value if the operation cannot be completed. For example, in our function that reads a file, it can return a Result type, where the question mark indicates that an error might be returned if the file cannot be read, or on the other hand the final result. In other words, used to short-circuit a chain of computations and return early if a condition is not met. fn read_username_from_file() -> Result<String, io::Error> {
    let mut f = File::open("username.txt")?;
    let mut s = String::new();
    f.read_to_string(&mut s)?;
    Ok(s)
} Every time you see a ?, that’s a possible early return from the function in case of Error, else , f will hold the file and handle the ‘Ok’ contained and then the execution of the function continues (similar to an unwrap function). Why use crates to Handle errors? The standard library does not provide all solutions for Error Handling. In fact, different errors may be returned by the same function, making it increasingly difficult to handle them precisely. Personal anecdote, in our company we developed an API security tool written in Rust, and we need to re-write a good part of it to have better error handling. Cherrybomb For example: Or the same message error can be displayed multiple times. This is why we need to define our own custom Error enum. Then our function will look like: Customize Errors Thiserror focuses on creating structured errors and has only one trait that can be used to define new errors: Thiserror is an error-handling library for Rust that provides a powerful yet concise syntax to create custom error types. In the cargo toml: [dependencies]   thiserror = "1.0" It allows developers to create custom error types and handlers without having to write a lot of boilerplate code. Thanks to thiserror crate, we can customize our error messages. It also provides features to automatically convert between custom error types and the standard error type. We will see it in the next Chapter with Dynamic Errors. Create new errors through #[derive(Error)]. Enums, structs with named fields, tuple structs, and unit structs are all possible. A Display img is generated for your error if you provide #[error("...")] messages on the struct or each variant of your enum and support string interpolation. An example taken from : docs.rs Dealing with Dynamic Errors If you want to be able to use ‘?’, your Error type must implement the From trait for the error types of your dependencies. Your program or library may use many dependencies, each of which has its own error. You have two different structs of custom error, and we call a function that return one specific type. For example: So when we call our main function that returns a type, we encounter the following error: ErrorA So one of the solutions is to implement the trait for the struct . From<ErrorB> ErrorA Our code looks like this now: Another solution to this problem is to return dynamic errors. To handle dynamic errors in Rust, in the case of an Err value, you can use the box operator to return the error as a Box (a trait object of the Error trait). This allows the error type to be determined at runtime, rather than at compile time, making it easier to work with errors of different types. The Box can then be used to store any type of Error, including those from external libraries or custom errors. The Box can then be used to propagate the Error up the call stack, allowing for the appropriate handling of the error at each stage. Thiserror crate To have cleaner code, let's use thiserror crate. The crate can help handle dynamic errors in Rust by allowing the user to define custom error types. It does this through the macro. This macro allows the user to define a custom error type with a specific set of parameters, such as an error code, a message, and the source of the error. thiserror #[derive(thiserror::Error)] The user can then use this error type to return an appropriate error value in the event of a dynamic error. Additionally, the crate also provides several helpful methods, such as , which can be used to chain together multiple errors into a single error chain. In the following, we have created our error type , then we used the From trait to convert errors into our custom error type. If a dynamic error occurs, you can create a new instance of your error type and return it to the caller. See function in line 13. thiserror display_chain ErrorB ErrorB ErrorA returns_error_a() Anyhow crate anyhow was written by the same author, dtolnay, and released in the same week as thiserror. The can be used to return errors of any type that implement the trait and will display a nicely formatted error message if the program crashes. The most common way to use the crate is to wrap your code in a Result type. This type is an alias for the type, and it allows you to handle success or failure cases separately. anyhow std::error::Error std::result::Result<T, E> When an error occurs, for example, you can use the method to provide more information about the error, or use the with_chain() method to chain multiple errors together. The anyhow crate provides several convenient macros to simplify the process of constructing and handling errors. These macros include the and macros. The former can be used to quickly construct an error value, while the latter can be used to wrap a function call and automatically handle any errors that occur. context() bail!() try_with_context!() Comparison The main difference between anyhow and the Thiserror crate in Rust is the way in which errors are handled. Anyhow allows for error handling using any type that implements the Error trait, whereas, Thiserror requires you to explicitly define the error types using macros. Anyhow is an error-handling library for Rust that provides an easy way to convert errors into a uniform type. It allows the writing of concise and powerful error-handling code by automatically converting many different types of errors into a single, common type. In conclusion, in we choose to combine the two, in order to create a custom error type with thiserror and managed it with the anyhow crate. Cherrybomb Also published here.

A Comprehensive Guide for Handling Errors in Rust

Yesterday, announced a new feature for the application load balancer that has been a long time coming. Amazon _We are pleased to announce support for Host-based routing on the Application Load Balancer. Host-based routing allows…_aws.amazon.com Elastic Load Balancing Adds Support for Host-based Routing and Increased Rules on its Application… At , we are using ALB to route traffic to our ECS cluster. We are using target groups to target our many micro-services. Globality This feature removed a lot of complexity in our routing system and I thought it’s worth a quick post on configuring this with terraform The code resource "aws_alb" "alb" {name            = "${var.name}-alb-${var.environment}"internal        = truesecurity_groups = ["${var.security_group_id}"]subnets         = ["${split(",", var.subnet_ids)}"] tags {Environment = "${var.environment}"}} resource "aws_alb_target_group" "alb_targets" {count     = "${length(keys(var.services_map))}"name      = "${element(values(var.services_map), count.index)}-${var.environment}"port      = "${element(keys(var.services_map), count.index)}"protocol  = "HTTP"vpc_id    = "${var.vpc_id}" health_check {healthy_threshold   = 2interval            = 15path                = "/api/health"timeout             = 10unhealthy_threshold = 2} tags {Color       = "${var.color}"Service     = "${element(values(var.services_map), count.index)}"Tier        = "${var.name}"Environment = "${var.environment}"}} resource "aws_alb_listener" "alb_listener" {count             = "1"load_balancer_arn = "${aws_alb.alb.arn}"port              = "${element(keys(var.services_map), count.index)}"protocol          = "HTTPS"ssl_policy        = "ELBSecurityPolicy-2015-05"certificate_arn   = "${var.ssl_certificate_arn}" default_action {target_group_arn = "${element(aws_alb_target_group.alb_targets.*.arn, 0)}"type = "forward"}} resource "aws_alb_listener_rule" "route_path" {count         = "${length(values(var.services_map))}"listener_arn  = "${aws_alb_listener.alb_listener.arn}"priority      = "${1 + count.index}" action {type = "forward"target_group_arn = "${element(aws_alb_target_group.alb_targets.*.arn, count.index)}"} condition {field = "host-header"values = ["${element(values(var.services_map), count.index)}.${var.domain}"]} lifecycle {ignore_changes = ["priority"]}} As you can see, we are creating a single load balancer that has a single listener. This listener is the “default action” and can have many routing rules. In the past, those rules consisted of path only, the new feature is adding host-header. So, take our example. The default action is a single micro-service out of all our micro-services. Then, we add rules for the HTTP Host of all the other services and route the traffic to their target groups. More than just a short code post Really more than anything, this is a culture post. If you know you have pains in your system you need to always be looking for a solution and how you can make it better. This feature came out yesterday and today we are already using it and converged out entire dev cluster. This removed about 200 lines of code from our terraform repository and probably about the same amount from the scripts we use to manage and flip environments on deployment. is how hackers start their afternoons. We’re a part of the family. We are now and happy to opportunities. Hacker Noon @AMI accepting submissions discuss advertising & sponsorship To learn more, , , or simply, read our about page like/message us on Facebook tweet/DM @HackerNoon. If you enjoyed this story, we recommend reading our and . Until next time, don’t take the realities of the world for granted! latest tech stories trending tech stories

Stories, News & Mentions about BLUESECURITY

Bluesecurity’s Stories on HackerNoon

Bluesecurity's News & Mentions